activerecord 7.1.5.1 → 8.0.2

data/lib/active_record/connection_adapters/abstract/query_cache.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "concurrent/map"
+require "concurrent/atomic/atomic_fixnum"
 
 module ActiveRecord
   module ConnectionAdapters # :nodoc:
@@ -13,15 +14,16 @@ module ActiveRecord
             :truncate_tables, :rollback_to_savepoint, :rollback_db_transaction, :restart_db_transaction,
             :exec_insert_all
 
-          base.set_callback :checkout, :after, :configure_query_cache!
-          base.set_callback :checkin, :after, :disable_query_cache!
+          base.set_callback :checkin, :after, :unset_query_cache!
         end
 
         def dirties_query_cache(base, *method_names)
           method_names.each do |method_name|
             base.class_eval <<-end_code, __FILE__, __LINE__ + 1
               def #{method_name}(...)
-                ActiveRecord::Base.clear_query_caches_for_current_thread
+                if pool.dirties_query_cache
+                  ActiveRecord::Base.clear_query_caches_for_current_thread
+                end
                 super
               end
             end_code
@@ -29,60 +31,196 @@ module ActiveRecord
         end
       end
 
-      module ConnectionPoolConfiguration
-        def initialize(*)
+      class Store # :nodoc:
+        attr_accessor :enabled, :dirties
+        alias_method :enabled?, :enabled
+        alias_method :dirties?, :dirties
+
+        def initialize(version, max_size)
+          @version = version
+          @current_version = version.value
+          @map = {}
+          @max_size = max_size
+          @enabled = false
+          @dirties = true
+        end
+
+        def size
+          check_version
+          @map.size
+        end
+
+        def empty?
+          check_version
+          @map.empty?
+        end
+
+        def [](key)
+          check_version
+          return unless @enabled
+
+          if entry = @map.delete(key)
+            @map[key] = entry
+          end
+        end
+
+        def compute_if_absent(key)
+          check_version
+
+          return yield unless @enabled
+
+          if entry = @map.delete(key)
+            return @map[key] = entry
+          end
+
+          if @max_size && @map.size >= @max_size
+            @map.shift # evict the oldest entry
+          end
+
+          @map[key] ||= yield
+        end
+
+        def clear
+          @map.clear
+          self
+        end
+
+        private
+          def check_version
+            if @current_version != @version.value
+              @map.clear
+              @current_version = @version.value
+            end
+          end
+      end
+
+      class QueryCacheRegistry # :nodoc:
+        def initialize
+          @mutex = Mutex.new
+          @map = ConnectionPool::WeakThreadKeyMap.new
+        end
+
+        def compute_if_absent(context)
+          @map[context] || @mutex.synchronize do
+            @map[context] ||= yield
+          end
+        end
+
+        def clear
+          @map.synchronize do
+            @map.clear
+          end
+        end
+      end
+
+      module ConnectionPoolConfiguration # :nodoc:
+        def initialize(...)
           super
-          @query_cache_enabled = Concurrent::Map.new { false }
+          @query_cache_version = Concurrent::AtomicFixnum.new
+          @thread_query_caches = QueryCacheRegistry.new
+          @query_cache_max_size = \
+            case query_cache = db_config&.query_cache
+            when 0, false
+              nil
+            when Integer
+              query_cache
+            when nil
+              DEFAULT_SIZE
+            end
+        end
+
+        def checkout_and_verify(connection)
+          super
+          connection.query_cache ||= query_cache
+          connection
+        end
+
+        # Disable the query cache within the block.
+        def disable_query_cache(dirties: true)
+          cache = query_cache
+          old_enabled, cache.enabled, old_dirties, cache.dirties = cache.enabled, false, cache.dirties, dirties
+          begin
+            yield
+          ensure
+            cache.enabled, cache.dirties = old_enabled, old_dirties
+          end
+        end
+
+        def enable_query_cache
+          cache = query_cache
+          old_enabled, cache.enabled, old_dirties, cache.dirties = cache.enabled, true, cache.dirties, true
+          begin
+            yield
+          ensure
+            cache.enabled, cache.dirties = old_enabled, old_dirties
+          end
         end
 
         def enable_query_cache!
-          @query_cache_enabled[connection_cache_key(current_thread)] = true
-          connection.enable_query_cache! if active_connection?
+          query_cache.enabled = true
+          query_cache.dirties = true
         end
 
         def disable_query_cache!
-          @query_cache_enabled.delete connection_cache_key(current_thread)
-          connection.disable_query_cache! if active_connection?
+          query_cache.enabled = false
+          query_cache.dirties = true
         end
 
         def query_cache_enabled
-          @query_cache_enabled[connection_cache_key(current_thread)]
+          query_cache.enabled
+        end
+
+        def dirties_query_cache
+          query_cache.dirties
+        end
+
+        def clear_query_cache
+          if @pinned_connection
+            # With transactional fixtures, and especially systems test
+            # another thread may use the same connection, but with a different
+            # query cache. So we must clear them all.
+            @query_cache_version.increment
+          end
+          query_cache.clear
+        end
+
+        def query_cache
+          @thread_query_caches.compute_if_absent(ActiveSupport::IsolatedExecutionState.context) do
+            Store.new(@query_cache_version, @query_cache_max_size)
+          end
         end
       end
 
-      attr_reader :query_cache, :query_cache_enabled
+      attr_accessor :query_cache
 
       def initialize(*)
         super
-        @query_cache         = {}
-        @query_cache_enabled = false
-        @query_cache_max_size = nil
+        @query_cache = nil
+      end
+
+      def query_cache_enabled
+        @query_cache&.enabled?
       end
 
       # Enable the query cache within the block.
-      def cache
-        old, @query_cache_enabled = @query_cache_enabled, true
-        yield
-      ensure
-        @query_cache_enabled = old
-        clear_query_cache unless @query_cache_enabled
+      def cache(&block)
+        pool.enable_query_cache(&block)
       end
 
       def enable_query_cache!
-        @query_cache_enabled = true
+        pool.enable_query_cache!
       end
 
-      def disable_query_cache!
-        @query_cache_enabled = false
-        clear_query_cache
+      # Disable the query cache within the block.
+      #
+      # Set <tt>dirties: false</tt> to prevent query caches on all connections from being cleared by write operations.
+      # (By default, write operations dirty all connections' query caches in case they are replicas whose cache would now be outdated.)
+      def uncached(dirties: true, &block)
+        pool.disable_query_cache(dirties: dirties, &block)
       end
 
-      # Disable the query cache within the block.
-      def uncached
-        old, @query_cache_enabled = @query_cache_enabled, false
-        yield
-      ensure
-        @query_cache_enabled = old
+      def disable_query_cache!
+        pool.disable_query_cache!
       end
 
       # Clears the query cache.
@@ -92,24 +230,22 @@ module ActiveRecord
       # the same SQL query and repeatedly return the same result each time, silently
       # undermining the randomness you were expecting.
       def clear_query_cache
-        @lock.synchronize do
-          @query_cache.clear
-        end
+        pool.clear_query_cache
       end
 
-      def select_all(arel, name = nil, binds = [], preparable: nil, async: false) # :nodoc:
+      def select_all(arel, name = nil, binds = [], preparable: nil, async: false, allow_retry: false) # :nodoc:
         arel = arel_from_relation(arel)
 
         # If arel is locked this is a SELECT ... FOR UPDATE or somesuch.
         # Such queries should not be cached.
-        if @query_cache_enabled && !(arel.respond_to?(:locked) && arel.locked)
-          sql, binds, preparable = to_sql_and_binds(arel, binds, preparable)
+        if @query_cache&.enabled? && !(arel.respond_to?(:locked) && arel.locked)
+          sql, binds, preparable, allow_retry = to_sql_and_binds(arel, binds, preparable)
 
           if async
-            result = lookup_sql_cache(sql, name, binds) || super(sql, name, binds, preparable: preparable, async: async)
+            result = lookup_sql_cache(sql, name, binds) || super(sql, name, binds, preparable: preparable, async: async, allow_retry: allow_retry)
             FutureResult.wrap(result)
           else
-            cache_sql(sql, name, binds) { super(sql, name, binds, preparable: preparable, async: async) }
+            cache_sql(sql, name, binds) { super(sql, name, binds, preparable: preparable, async: async, allow_retry: allow_retry) }
           end
         else
           super
@@ -117,55 +253,56 @@ module ActiveRecord
       end
 
       private
+        def unset_query_cache!
+          @query_cache = nil
+        end
+
         def lookup_sql_cache(sql, name, binds)
           key = binds.empty? ? sql : [sql, binds]
-          hit = false
-          result = nil
 
+          result = nil
           @lock.synchronize do
-            if (result = @query_cache.delete(key))
-              hit = true
-              @query_cache[key] = result
-            end
+            result = @query_cache[key]
           end
 
-          if hit
+          if result
             ActiveSupport::Notifications.instrument(
               "sql.active_record",
-              cache_notification_info(sql, name, binds)
+              cache_notification_info_result(sql, name, binds, result)
             )
-
-            result
           end
+
+          result
         end
 
         def cache_sql(sql, name, binds)
           key = binds.empty? ? sql : [sql, binds]
           result = nil
-          hit = false
+          hit = true
 
           @lock.synchronize do
-            if (result = @query_cache.delete(key))
-              hit = true
-              @query_cache[key] = result
-            else
-              result = @query_cache[key] = yield
-              if @query_cache_max_size && @query_cache.size > @query_cache_max_size
-                @query_cache.shift
-              end
+            result = @query_cache.compute_if_absent(key) do
+              hit = false
+              yield
             end
           end
 
           if hit
             ActiveSupport::Notifications.instrument(
               "sql.active_record",
-              cache_notification_info(sql, name, binds)
+              cache_notification_info_result(sql, name, binds, result)
             )
           end
 
           result.dup
         end
 
+        def cache_notification_info_result(sql, name, binds, result)
+          payload = cache_notification_info(sql, name, binds)
+          payload[:row_count] = result.length
+          payload
+        end
+
         # Database adapters can override this method to
         # provide custom cache information.
         def cache_notification_info(sql, name, binds)
@@ -175,26 +312,10 @@ module ActiveRecord
             type_casted_binds: -> { type_casted_binds(binds) },
             name: name,
             connection: self,
+            transaction: current_transaction.user_transaction.presence,
             cached: true
           }
         end
-
-        def configure_query_cache!
-          case query_cache = pool.db_config.query_cache
-          when 0, false
-            return
-          when Integer
-            @query_cache_max_size = query_cache
-          when nil
-            @query_cache_max_size = DEFAULT_SIZE
-          else
-            @query_cache_max_size = nil # no limit
-          end
-
-          if pool.query_cache_enabled
-            enable_query_cache!
-          end
-        end
     end
   end
 end

data/lib/active_record/connection_adapters/abstract/quoting.rb

@@ -7,6 +7,67 @@ module ActiveRecord
   module ConnectionAdapters # :nodoc:
     # = Active Record Connection Adapters \Quoting
     module Quoting
+      extend ActiveSupport::Concern
+
+      module ClassMethods # :nodoc:
+        # Regexp for column names (with or without a table name prefix).
+        # Matches the following:
+        #
+        #   "#{table_name}.#{column_name}"
+        #   "#{column_name}"
+        def column_name_matcher
+          /
+            \A
+            (
+              (?:
+                # table_name.column_name | function(one or no argument)
+                ((?:\w+\.)?\w+ | \w+\((?:|\g<2>)\))
+              )
+              (?:(?:\s+AS)?\s+\w+)?
+            )
+            (?:\s*,\s*\g<1>)*
+            \z
+          /ix
+        end
+
+        # Regexp for column names with order (with or without a table name prefix,
+        # with or without various order modifiers). Matches the following:
+        #
+        #   "#{table_name}.#{column_name}"
+        #   "#{table_name}.#{column_name} #{direction}"
+        #   "#{table_name}.#{column_name} #{direction} NULLS FIRST"
+        #   "#{table_name}.#{column_name} NULLS LAST"
+        #   "#{column_name}"
+        #   "#{column_name} #{direction}"
+        #   "#{column_name} #{direction} NULLS FIRST"
+        #   "#{column_name} NULLS LAST"
+        def column_name_with_order_matcher
+          /
+            \A
+            (
+              (?:
+                # table_name.column_name | function(one or no argument)
+                ((?:\w+\.)?\w+ | \w+\((?:|\g<2>)\))
+              )
+              (?:\s+ASC|\s+DESC)?
+              (?:\s+NULLS\s+(?:FIRST|LAST))?
+            )
+            (?:\s*,\s*\g<1>)*
+            \z
+          /ix
+        end
+
+        # Quotes the column name. Must be implemented by subclasses
+        def quote_column_name(column_name)
+          raise NotImplementedError
+        end
+
+        # Quotes the table name. Defaults to column name quoting.
+        def quote_table_name(table_name)
+          quote_column_name(table_name)
+        end
+      end
+
       # Quotes the column value to help prevent
       # {SQL injection attacks}[https://en.wikipedia.org/wiki/SQL_injection].
       def quote(value)
@@ -23,9 +84,6 @@ module ActiveRecord
         when Type::Time::Value then "'#{quoted_time(value)}'"
         when Date, Time then "'#{quoted_date(value)}'"
         when Class      then "'#{value}'"
-        when ActiveSupport::Duration
-          warn_quote_duration_deprecated
-          value.to_s
         else raise TypeError, "can't quote #{value.class.name}"
         end
       end
@@ -48,21 +106,6 @@ module ActiveRecord
         end
       end
 
-      # Quote a value to be used as a bound parameter of unknown type. For example,
-      # MySQL might perform dangerous castings when comparing a string to a number,
-      # so this method will cast numbers to string.
-      #
-      # Deprecated: Consider `Arel.sql("... ? ...", value)` or
-      # +sanitize_sql+ instead.
-      def quote_bound_value(value)
-        ActiveRecord.deprecator.warn(<<~MSG.squish)
-          #quote_bound_value is deprecated and will be removed in Rails 7.2.
-          Consider Arel.sql(".. ? ..", value) or #sanitize_sql instead.
-        MSG
-
-        quote(cast_bound_value(value))
-      end
-
       # Cast a value to be used as a bound parameter of unknown type. For example,
       # MySQL might perform dangerous castings when comparing a string to a number,
       # so this method will cast numbers to string.
@@ -89,14 +132,14 @@ module ActiveRecord
         s.gsub("\\", '\&\&').gsub("'", "''") # ' (for ruby-mode)
       end
 
-      # Quotes the column name. Defaults to no quoting.
+      # Quotes the column name.
       def quote_column_name(column_name)
-        column_name.to_s
+        self.class.quote_column_name(column_name)
       end
 
-      # Quotes the table name. Defaults to column name quoting.
+      # Quotes the table name.
       def quote_table_name(table_name)
-        quote_column_name(table_name)
+        self.class.quote_table_name(table_name)
       end
 
       # Override to return the quoted table name for assignment. Defaults to
@@ -177,62 +220,9 @@ module ActiveRecord
         comment
       end
 
-      def column_name_matcher # :nodoc:
-        COLUMN_NAME
-      end
-
-      def column_name_with_order_matcher # :nodoc:
-        COLUMN_NAME_WITH_ORDER
-      end
-
-      # Regexp for column names (with or without a table name prefix).
-      # Matches the following:
-      #
-      #   "#{table_name}.#{column_name}"
-      #   "#{column_name}"
-      COLUMN_NAME = /
-        \A
-        (
-          (?:
-            # table_name.column_name | function(one or no argument)
-            ((?:\w+\.)?\w+ | \w+\((?:|\g<2>)\))
-          )
-          (?:(?:\s+AS)?\s+\w+)?
-        )
-        (?:\s*,\s*\g<1>)*
-        \z
-      /ix
-
-      # Regexp for column names with order (with or without a table name prefix,
-      # with or without various order modifiers). Matches the following:
-      #
-      #   "#{table_name}.#{column_name}"
-      #   "#{table_name}.#{column_name} #{direction}"
-      #   "#{table_name}.#{column_name} #{direction} NULLS FIRST"
-      #   "#{table_name}.#{column_name} NULLS LAST"
-      #   "#{column_name}"
-      #   "#{column_name} #{direction}"
-      #   "#{column_name} #{direction} NULLS FIRST"
-      #   "#{column_name} NULLS LAST"
-      COLUMN_NAME_WITH_ORDER = /
-        \A
-        (
-          (?:
-            # table_name.column_name | function(one or no argument)
-            ((?:\w+\.)?\w+ | \w+\((?:|\g<2>)\))
-          )
-          (?:\s+ASC|\s+DESC)?
-          (?:\s+NULLS\s+(?:FIRST|LAST))?
-        )
-        (?:\s*,\s*\g<1>)*
-        \z
-      /ix
-
-      private_constant :COLUMN_NAME, :COLUMN_NAME_WITH_ORDER
-
       private
         def type_casted_binds(binds)
-          binds.map do |value|
+          binds&.map do |value|
             if ActiveModel::Attribute === value
               type_cast(value.value_for_database)
             else
@@ -244,22 +234,6 @@ module ActiveRecord
         def lookup_cast_type(sql_type)
           type_map.lookup(sql_type)
         end
-
-        def warn_quote_duration_deprecated
-          ActiveRecord.deprecator.warn(<<~MSG)
-            Using ActiveSupport::Duration as an interpolated bind parameter in a SQL
-            string template is deprecated. To avoid this warning, you should explicitly
-            convert the duration to a more specific database type. For example, if you
-            want to use a duration as an integer number of seconds:
-            ```
-            Record.where("duration = ?", 1.hour.to_i)
-            ```
-            If you want to use a duration as an ISO 8601 string:
-            ```
-            Record.where("duration = ?", 1.hour.iso8601)
-            ```
-          MSG
-        end
     end
   end
 end

data/lib/active_record/connection_adapters/abstract/schema_creation.rb

@@ -28,6 +28,7 @@ module ActiveRecord
           sql << o.foreign_key_drops.map { |fk| visit_DropForeignKey fk }.join(" ")
           sql << o.check_constraint_adds.map { |con| visit_AddCheckConstraint con }.join(" ")
           sql << o.check_constraint_drops.map { |con| visit_DropCheckConstraint con }.join(" ")
+          sql << o.constraint_drops.map { |con| visit_DropConstraint con }.join(" ")
         end
 
         def visit_ColumnDefinition(o)
@@ -96,9 +97,11 @@ module ActiveRecord
           "ADD #{accept(o)}"
         end
 
-        def visit_DropForeignKey(name)
+        def visit_DropConstraint(name)
           "DROP CONSTRAINT #{quote_column_name(name)}"
         end
+        alias :visit_DropForeignKey :visit_DropConstraint
+        alias :visit_DropCheckConstraint :visit_DropConstraint
 
         def visit_CreateIndexDefinition(o)
           index = o.index
@@ -127,10 +130,6 @@ module ActiveRecord
           "ADD #{accept(o)}"
         end
 
-        def visit_DropCheckConstraint(name)
-          "DROP CONSTRAINT #{quote_column_name(name)}"
-        end
-
         def quoted_columns(o)
           String === o.columns ? o.columns : quoted_columns_for_index(o.columns, o.column_options)
         end

data/lib/active_record/connection_adapters/abstract/schema_definitions.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-
 module ActiveRecord
   module ConnectionAdapters # :nodoc:
     # Abstract representation of an index definition on a table. Instances of
@@ -160,6 +159,8 @@ module ActiveRecord
       end
 
       def defined_for?(to_table: nil, validate: nil, **options)
+        options = options.slice(*self.options.keys)
+
         (to_table.nil? || to_table.to_s == self.to_table) &&
           (validate.nil? || validate == self.options.fetch(:validate, validate)) &&
           options.all? { |k, v| Array(self.options[k]).map(&:to_s) == Array(v).map(&:to_s) }
@@ -186,6 +187,8 @@ module ActiveRecord
       end
 
       def defined_for?(name:, expression: nil, validate: nil, **options)
+        options = options.slice(*self.options.keys)
+
         self.name == name.to_s &&
           (validate.nil? || validate == self.options.fetch(:validate, validate)) &&
           options.all? { |k, v| self.options[k].to_s == v.to_s }
@@ -348,7 +351,7 @@ module ActiveRecord
     # Inside migration files, the +t+ object in {create_table}[rdoc-ref:SchemaStatements#create_table]
     # is actually of this type:
     #
-    #   class SomeMigration < ActiveRecord::Migration[7.1]
+    #   class SomeMigration < ActiveRecord::Migration[8.0]
     #     def up
     #       create_table :foo do |t|
     #         puts t.class  # => "ActiveRecord::ConnectionAdapters::TableDefinition"
@@ -431,7 +434,7 @@ module ActiveRecord
       #
       # == Examples
       #
-      #  # Assuming +td+ is an instance of TableDefinition
+      #  # Assuming `td` is an instance of TableDefinition
       #  td.column(:granted, :boolean, index: true)
       #
       # == Short-hand examples
@@ -622,6 +625,7 @@ module ActiveRecord
       attr_reader :adds
       attr_reader :foreign_key_adds, :foreign_key_drops
       attr_reader :check_constraint_adds, :check_constraint_drops
+      attr_reader :constraint_drops
 
       def initialize(td)
         @td   = td
@@ -630,6 +634,7 @@ module ActiveRecord
         @foreign_key_drops = []
         @check_constraint_adds = []
         @check_constraint_drops = []
+        @constraint_drops = []
       end
 
       def name; @td.name; end
@@ -650,6 +655,10 @@ module ActiveRecord
         @check_constraint_drops << constraint_name
       end
 
+      def drop_constraint(constraint_name)
+        @constraint_drops << constraint_name
+      end
+
       def add_column(name, type, **options)
         name = name.to_s
         type = type.to_sym