activerecord 6.1.7.6 → 7.0.0

data/lib/active_record/future_result.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  class FutureResult # :nodoc:
+    class EventBuffer
+      def initialize(future_result, instrumenter)
+        @future_result = future_result
+        @instrumenter = instrumenter
+        @events = []
+      end
+
+      def instrument(name, payload = {}, &block)
+        event = @instrumenter.new_event(name, payload)
+        @events << event
+        event.record(&block)
+      end
+
+      def flush
+        events, @events = @events, []
+        events.each do |event|
+          event.payload[:lock_wait] = @future_result.lock_wait
+          ActiveSupport::Notifications.publish_event(event)
+        end
+      end
+    end
+
+    Canceled = Class.new(ActiveRecordError)
+
+    delegate :empty?, :to_a, to: :result
+
+    attr_reader :lock_wait
+
+    def initialize(pool, *args, **kwargs)
+      @mutex = Mutex.new
+
+      @session = nil
+      @pool = pool
+      @args = args
+      @kwargs = kwargs
+
+      @pending = true
+      @error = nil
+      @result = nil
+      @instrumenter = ActiveSupport::Notifications.instrumenter
+      @event_buffer = nil
+    end
+
+    def schedule!(session)
+      @session = session
+      @pool.schedule_query(self)
+    end
+
+    def execute!(connection)
+      execute_query(connection)
+    end
+
+    def cancel
+      @pending = false
+      @error = Canceled
+      self
+    end
+
+    def execute_or_skip
+      return unless pending?
+
+      @pool.with_connection do |connection|
+        return unless @mutex.try_lock
+        begin
+          if pending?
+            @event_buffer = EventBuffer.new(self, @instrumenter)
+            connection.with_instrumenter(@event_buffer) do
+              execute_query(connection, async: true)
+            end
+          end
+        ensure
+          @mutex.unlock
+        end
+      end
+    end
+
+    def result
+      execute_or_wait
+      @event_buffer&.flush
+
+      if canceled?
+        raise Canceled
+      elsif @error
+        raise @error
+      else
+        @result
+      end
+    end
+
+    def pending?
+      @pending && (!@session || @session.active?)
+    end
+
+    private
+      def canceled?
+        @session && !@session.active?
+      end
+
+      def execute_or_wait
+        if pending?
+          start = Process.clock_gettime(Process::CLOCK_MONOTONIC, :float_millisecond)
+          @mutex.synchronize do
+            if pending?
+              execute_query(@pool.connection)
+            else
+              @lock_wait = (Process.clock_gettime(Process::CLOCK_MONOTONIC, :float_millisecond) - start)
+            end
+          end
+        else
+          @lock_wait = 0.0
+        end
+      end
+
+      def execute_query(connection, async: false)
+        @result = exec_query(connection, *@args, **@kwargs, async: async)
+      rescue => error
+        @error = error
+      ensure
+        @pending = false
+      end
+
+      def exec_query(connection, *args, **kwargs)
+        connection.exec_query(*args, **kwargs)
+      end
+
+      class SelectAll < FutureResult # :nodoc:
+        private
+          def exec_query(*, **)
+            super
+          rescue ::RangeError
+            ActiveRecord::Result.empty
+          end
+      end
+  end
+end

data/lib/active_record/gem_version.rb

@@ -7,10 +7,10 @@ module ActiveRecord
   end
 
   module VERSION
-    MAJOR = 6
-    MINOR = 1
-    TINY  = 7
-    PRE   = "6"
+    MAJOR = 7
+    MINOR = 0
+    TINY  = 0
+    PRE   = nil
 
     STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")
   end

data/lib/active_record/inheritance.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "active_support/inflector"
 require "active_support/core_ext/hash/indifferent_access"
 
 module ActiveRecord
@@ -43,6 +44,8 @@ module ActiveRecord
       # Determines whether to store the full constant name including namespace when using STI.
       # This is true, by default.
       class_attribute :store_full_sti_class, instance_writer: false, default: true
+
+      set_base_class
     end
 
     module ClassMethods
@@ -85,7 +88,7 @@ module ActiveRecord
         end
       end
 
-      def finder_needs_type_condition? #:nodoc:
+      def finder_needs_type_condition? # :nodoc:
         # This is like this because benchmarking justifies the strange :false stuff
         :true == (@finder_needs_type_condition ||= descends_from_active_record? ? :false : :true)
       end
@@ -98,17 +101,7 @@ module ActiveRecord
       #
       # If B < A and C < B and if A is an abstract_class then both B.base_class
       # and C.base_class would return B as the answer since A is an abstract_class.
-      def base_class
-        unless self < Base
-          raise ActiveRecordError, "#{name} doesn't belong in a hierarchy descending from ActiveRecord"
-        end
-
-        if superclass == Base || superclass.abstract_class?
-          self
-        else
-          superclass.base_class
-        end
-      end
+      attr_reader :base_class
 
       # Returns whether the class is a base class.
       # See #base_class for more information.
@@ -164,6 +157,21 @@ module ActiveRecord
         defined?(@abstract_class) && @abstract_class == true
       end
 
+      # Sets the application record class for Active Record
+      #
+      # This is useful if your application uses a different class than
+      # ApplicationRecord for your primary abstract class. This class
+      # will share a database connection with Active Record. It is the class
+      # that connects to your primary database.
+      def primary_abstract_class
+        if ActiveRecord.application_record_class && ActiveRecord.application_record_class.name != name
+          raise ArgumentError, "The `primary_abstract_class` is already set to #{ActiveRecord.application_record_class.inspect}. There can only be one `primary_abstract_class` in an application."
+        end
+
+        self.abstract_class = true
+        ActiveRecord.application_record_class = self
+      end
+
       # Returns the value to be stored in the inheritance column for STI.
       def sti_name
         store_full_sti_class && store_full_class_name ? name : name.demodulize
@@ -174,7 +182,7 @@ module ActiveRecord
       # It is used to find the class correspondent to the value stored in the inheritance column.
       def sti_class_for(type_name)
         if store_full_sti_class && store_full_class_name
-          ActiveSupport::Dependencies.constantize(type_name)
+          type_name.constantize
         else
           compute_type(type_name)
         end
@@ -196,17 +204,31 @@ module ActiveRecord
       # It is used to find the class correspondent to the value stored in the polymorphic type column.
       def polymorphic_class_for(name)
         if store_full_class_name
-          ActiveSupport::Dependencies.constantize(name)
+          name.constantize
         else
           compute_type(name)
         end
       end
 
       def inherited(subclass)
+        subclass.set_base_class
         subclass.instance_variable_set(:@_type_candidates_cache, Concurrent::Map.new)
         super
       end
 
+      def dup # :nodoc:
+        # `initialize_dup` / `initialize_copy` don't work when defined
+        # in the `singleton_class`.
+        other = super
+        other.set_base_class
+        other
+      end
+
+      def initialize_clone(other) # :nodoc:
+        super
+        set_base_class
+      end
+
       protected
         # Returns the class type of the record using the current module as a prefix. So descendants of
         # MyApp::Business::Account would appear as MyApp::Business::AccountSubclass.
@@ -214,10 +236,10 @@ module ActiveRecord
           if type_name.start_with?("::")
             # If the type is prefixed with a scope operator then we assume that
             # the type_name is an absolute reference.
-            ActiveSupport::Dependencies.constantize(type_name)
+            type_name.constantize
           else
             type_candidate = @_type_candidates_cache[type_name]
-            if type_candidate && type_constant = ActiveSupport::Dependencies.safe_constantize(type_candidate)
+            if type_candidate && type_constant = type_candidate.safe_constantize
               return type_constant
             end
 
@@ -227,7 +249,7 @@ module ActiveRecord
             candidates << type_name
 
             candidates.each do |candidate|
-              constant = ActiveSupport::Dependencies.safe_constantize(candidate)
+              constant = candidate.safe_constantize
               if candidate == constant.to_s
                 @_type_candidates_cache[type_name] = candidate
                 return constant
@@ -238,6 +260,22 @@ module ActiveRecord
           end
         end
 
+        def set_base_class # :nodoc:
+          @base_class = if self == Base
+            self
+          else
+            unless self < Base
+              raise ActiveRecordError, "#{name} doesn't belong in a hierarchy descending from ActiveRecord"
+            end
+
+            if superclass == Base || superclass.abstract_class?
+              self
+            else
+              superclass.base_class
+            end
+          end
+        end
+
       private
         # Called by +instantiate+ to decide which class to use for a new
         # record instance. For single-table inheritance, we check the record

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_formatted_s(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_formatted_s(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

@@ -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
@@ -90,7 +90,9 @@ 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 = _primary_key_constraints_hash
+            update_constraints[locking_column] = _lock_value_for_database(locking_column)
 
             attribute_names = attribute_names.dup if attribute_names.frozen?
             attribute_names << locking_column
@@ -99,8 +101,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
@@ -121,10 +122,10 @@ module ActiveRecord
 
           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)
-          )
+          delete_constraints = _primary_key_constraints_hash
+          delete_constraints[locking_column] = _lock_value_for_database(locking_column)
+
+          affected_rows = self.class._delete_record(delete_constraints)
 
           if affected_rows != 1
             raise ActiveRecord::StaleObjectError.new(self, "destroy")

data/lib/active_record/locking/pessimistic.rb

@@ -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 <tt>#lock!</tt>).
+      #
+      # You can also pass options like <tt>requires_new:</tt>, <tt>isolation:</tt>,
+      # and <tt>joinable:</tt> to the wrapping transaction (see
+      # <tt>ActiveRecord::ConnectionAdapters::DatabaseStatements#transaction</tt>).
+      def with_lock(*args)
+        transaction_opts = args.extract_options!
+        lock = args.present? ? args.first : true
+        transaction(**transaction_opts) do
           lock!(lock)
           yield
         end