activerecord 7.0.0 → 7.2.1

data/lib/active_record/promise.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  class Promise < BasicObject
+    undef_method :==, :!, :!=
+
+    def initialize(future_result, block) # :nodoc:
+      @future_result = future_result
+      @block = block
+    end
+
+    # Returns whether the associated query is still being executed or not.
+    def pending?
+      @future_result.pending?
+    end
+
+    # Returns the query result.
+    # If the query wasn't completed yet, accessing +#value+ will block until the query completes.
+    # If the query failed, +#value+ will raise the corresponding error.
+    def value
+      return @value if defined? @value
+
+      result = @future_result.result
+      @value = if @block
+        @block.call(result)
+      else
+        result
+      end
+    end
+
+    # Returns a new +ActiveRecord::Promise+ that will apply the passed block
+    # when the value is accessed:
+    #
+    #   Post.async_pick(:title).then { |title| title.upcase }.value
+    #   # => "POST TITLE"
+    def then(&block)
+      Promise.new(@future_result, @block ? @block >> block : block)
+    end
+
+    [:class, :respond_to?, :is_a?].each do |method|
+      define_method(method, ::Object.instance_method(method))
+    end
+
+    def inspect # :nodoc:
+      "#<ActiveRecord::Promise status=#{status}>"
+    end
+
+    def pretty_print(q) # :nodoc:
+      q.text(inspect)
+    end
+
+    private
+      def status
+        if @future_result.pending?
+          :pending
+        elsif @future_result.canceled?
+          :canceled
+        else
+          :complete
+        end
+      end
+
+      class Complete < self # :nodoc:
+        attr_reader :value
+
+        def initialize(value)
+          @value = value
+        end
+
+        def then
+          Complete.new(yield @value)
+        end
+
+        def pending?
+          false
+        end
+
+        private
+          def status
+            :complete
+          end
+      end
+  end
+end

data/lib/active_record/query_cache.rb

@@ -8,7 +8,13 @@ module ActiveRecord
       # If it's not, it will execute the given block.
       def cache(&block)
         if connected? || !configurations.empty?
-          connection.cache(&block)
+          pool = connection_pool
+          was_enabled = pool.query_cache_enabled
+          begin
+            pool.enable_query_cache(&block)
+          ensure
+            pool.clear_query_cache unless was_enabled
+          end
         else
           yield
         end
@@ -16,9 +22,12 @@ module ActiveRecord
 
       # Disable the query cache within the block if Active Record is configured.
       # If it's not, it will execute the given block.
-      def uncached(&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)
         if connected? || !configurations.empty?
-          connection.uncached(&block)
+          connection_pool.disable_query_cache(dirties: dirties, &block)
         else
           yield
         end
@@ -26,32 +35,17 @@ module ActiveRecord
     end
 
     def self.run
-      pools = []
-
-      if ActiveRecord.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
+      ActiveRecord::Base.connection_handler.each_connection_pool.reject(&:query_cache_enabled).each(&:enable_query_cache!)
     end
 
     def self.complete(pools)
-      pools.each { |pool| pool.disable_query_cache! }
+      pools.each do |pool|
+        pool.disable_query_cache!
+        pool.clear_query_cache
+      end
 
-      if ActiveRecord.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
+      ActiveRecord::Base.connection_handler.each_connection_pool do |pool|
+        pool.release_connection if pool.active_connection? && !pool.lease_connection.transaction_open?
       end
     end
 

data/lib/active_record/query_logs.rb

@@ -1,60 +1,67 @@
 # frozen_string_literal: true
 
 require "active_support/core_ext/module/attribute_accessors_per_thread"
+require "active_record/query_logs_formatter"
 
 module ActiveRecord
   # = Active Record Query Logs
   #
-  # Automatically tag SQL queries with runtime information.
+  # Automatically append comments to SQL queries with runtime information tags. This can be used to trace troublesome
+  # SQL statements back to the application code that generated these statements.
   #
-  # Default tags available for use:
+  # Query logs can be enabled via \Rails configuration in <tt>config/application.rb</tt> or an initializer:
+  #
+  #     config.active_record.query_log_tags_enabled = true
+  #
+  # By default the name of the application, the name and action of the controller, or the name of the job are logged.
+  # The default format is {SQLCommenter}[https://open-telemetry.github.io/opentelemetry-sqlcommenter/].
+  # The tags shown in a query comment can be configured via \Rails configuration:
+  #
+  #     config.active_record.query_log_tags = [ :application, :controller, :action, :job ]
+  #
+  # Active Record defines default tags available for use:
   #
   # * +application+
   # * +pid+
   # * +socket+
   # * +db_host+
   # * +database+
+  # * +source_location+
   #
-  # _Action Controller and Active Job tags are also defined when used in Rails:_
+  # Action Controller adds default tags when loaded:
   #
   # * +controller+
   # * +action+
-  # * +job+
+  # * +namespaced_controller+
   #
-  # The tags used in a query can be configured directly:
+  # Active Job adds default tags when loaded:
   #
-  #     ActiveRecord::QueryLogs.tags = [ :application, :controller, :action, :job ]
-  #
-  # or via Rails configuration:
+  # * +job+
   #
-  #     config.active_record.query_log_tags = [ :application, :controller, :action, :job ]
+  # New comment tags can be defined by adding them in a +Hash+ to the tags +Array+. Tags can have dynamic content by
+  # setting a +Proc+ or lambda value in the +Hash+, and can reference any value stored by \Rails in the +context+ object.
+  # ActiveSupport::CurrentAttributes can be used to store application values. Tags with +nil+ values are
+  # omitted from the query comment.
   #
-  # To add new comment tags, add a hash to the tags array containing the keys and values you
-  # want to add to the comment. Dynamic content can be created by setting a proc or lambda value in a hash,
-  # and can reference any value stored in the +context+ object.
+  # Escaping is performed on the string returned, however untrusted user input should not be used.
   #
   # Example:
   #
-  #    tags = [
-  #      :application,
-  #      {
-  #        custom_tag: ->(context) { context[:controller]&.controller_name },
-  #        custom_value: -> { Custom.value },
-  #      }
-  #    ]
-  #    ActiveRecord::QueryLogs.tags = tags
-  #
-  # The QueryLogs +context+ can be manipulated via the +ActiveSupport::ExecutionContext.set+ method.
-  #
-  # Temporary updates limited to the execution of a block:
-  #
-  #    ActiveSupport::ExecutionContext.set(foo: Bar.new) do
-  #      posts = Post.all
-  #    end
-  #
-  # Direct updates to a context value:
-  #
-  #    ActiveSupport::ExecutionContext[:foo] = Bar.new
+  #     config.active_record.query_log_tags = [
+  #       :namespaced_controller,
+  #       :action,
+  #       :job,
+  #       {
+  #         request_id: ->(context) { context[:controller]&.request&.request_id },
+  #         job_id: ->(context) { context[:job]&.job_id },
+  #         tenant_id: -> { Current.tenant&.id },
+  #         static: "value",
+  #       },
+  #     ]
+  #
+  # By default the name of the application, the name and action of the controller, or the name of the job are logged
+  # using the {SQLCommenter}[https://open-telemetry.github.io/opentelemetry-sqlcommenter/] format. This can be changed
+  # via {config.active_record.query_log_tags_format}[https://guides.rubyonrails.org/configuring.html#config-active-record-query-log-tags-format]
   #
   # Tag comments can be prepended to the query:
   #
@@ -63,59 +70,102 @@ module ActiveRecord
   # For applications where the content will not change during the lifetime of
   # the request or job execution, the tags can be cached for reuse in every query:
   #
-  #    ActiveRecord::QueryLogs.cache_query_log_tags = true
-  #
-  # This option can be set during application configuration or in a Rails initializer:
-  #
   #    config.active_record.cache_query_log_tags = true
   module QueryLogs
     mattr_accessor :taggings, instance_accessor: false, default: {}
     mattr_accessor :tags, instance_accessor: false, default: [ :application ]
     mattr_accessor :prepend_comment, instance_accessor: false, default: false
     mattr_accessor :cache_query_log_tags, instance_accessor: false, default: false
+    mattr_accessor :tags_formatter, instance_accessor: false
     thread_mattr_accessor :cached_comment, instance_accessor: false
 
     class << self
-      def call(sql) # :nodoc:
-        if prepend_comment
-          "#{self.comment} #{sql}"
+      def call(sql, connection) # :nodoc:
+        comment = self.comment(connection)
+
+        if comment.blank?
+          sql
+        elsif prepend_comment
+          "#{comment} #{sql}"
         else
-          "#{sql} #{self.comment}"
-        end.strip
+          "#{sql} #{comment}"
+        end
       end
 
       def clear_cache # :nodoc:
         self.cached_comment = nil
       end
 
+      # Updates the formatter to be what the passed in format is.
+      def update_formatter(format)
+        self.tags_formatter =
+          case format
+          when :legacy
+            LegacyFormatter.new
+          when :sqlcommenter
+            SQLCommenter.new
+          else
+            raise ArgumentError, "Formatter is unsupported: #{formatter}"
+          end
+      end
+
+      if Thread.respond_to?(:each_caller_location)
+        def query_source_location # :nodoc:
+          Thread.each_caller_location do |location|
+            frame = LogSubscriber.backtrace_cleaner.clean_frame(location.path)
+            return frame if frame
+          end
+          nil
+        end
+      else
+        def query_source_location # :nodoc:
+          LogSubscriber.backtrace_cleaner.clean(caller_locations(1).each).first
+        end
+      end
+
       ActiveSupport::ExecutionContext.after_change { ActiveRecord::QueryLogs.clear_cache }
 
       private
         # Returns an SQL comment +String+ containing the query log tags.
         # Sets and returns a cached comment if <tt>cache_query_log_tags</tt> is +true+.
-        def comment
+        def comment(connection)
           if cache_query_log_tags
-            self.cached_comment ||= uncached_comment
+            self.cached_comment ||= uncached_comment(connection)
           else
-            uncached_comment
+            uncached_comment(connection)
           end
         end
 
-        def uncached_comment
-          content = tag_content
+        def formatter
+          self.tags_formatter || self.update_formatter(:legacy)
+        end
+
+        def uncached_comment(connection)
+          content = tag_content(connection)
+
           if content.present?
             "/*#{escape_sql_comment(content)}*/"
           end
         end
 
         def escape_sql_comment(content)
-          content.to_s.gsub(%r{ (/ (?: | \g<1>) \*) \+? \s* | \s* (\* (?: | \g<2>) /) }x, "")
+          # Sanitize a string to appear within a SQL comment
+          # For compatibility, this also surrounding "/*+", "/*", and "*/"
+          # characters, possibly with single surrounding space.
+          # Then follows that by replacing any internal "*/" or "/ *" with
+          # "* /" or "/ *"
+          comment = content.to_s.dup
+          comment.gsub!(%r{\A\s*/\*\+?\s?|\s?\*/\s*\Z}, "")
+          comment.gsub!("*/", "* /")
+          comment.gsub!("/*", "/ *")
+          comment
         end
 
-        def tag_content
+        def tag_content(connection)
           context = ActiveSupport::ExecutionContext.to_h
+          context[:connection] ||= connection
 
-          tags.flat_map { |i| [*i] }.filter_map do |tag|
+          pairs = tags.flat_map { |i| [*i] }.filter_map do |tag|
             key, handler = tag
             handler ||= taggings[key]
 
@@ -130,8 +180,9 @@ module ActiveRecord
             else
               handler
             end
-            "#{key}:#{val}" unless val.nil?
-          end.join(",")
+            [key, val] unless val.nil?
+          end
+          self.formatter.format(pairs)
         end
     end
   end

data/lib/active_record/query_logs_formatter.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module QueryLogs
+    class LegacyFormatter # :nodoc:
+      def initialize
+        @key_value_separator = ":"
+      end
+
+      # Formats the key value pairs into a string.
+      def format(pairs)
+        pairs.map! do |key, value|
+          "#{key}#{key_value_separator}#{format_value(value)}"
+        end.join(",")
+      end
+
+      private
+        attr_reader :key_value_separator
+
+        def format_value(value)
+          value
+        end
+    end
+
+    class SQLCommenter < LegacyFormatter # :nodoc:
+      def initialize
+        @key_value_separator = "="
+      end
+
+      def format(pairs)
+        pairs.sort_by! { |pair| pair.first.to_s }
+        super
+      end
+
+      private
+        def format_value(value)
+          "'#{ERB::Util.url_encode(value)}'"
+        end
+    end
+  end
+end

data/lib/active_record/querying.rb

@@ -10,14 +10,16 @@ module ActiveRecord
       :first_or_create, :first_or_create!, :first_or_initialize,
       :find_or_create_by, :find_or_create_by!, :find_or_initialize_by,
       :create_or_find_by, :create_or_find_by!,
-      :destroy_all, :delete_all, :update_all, :touch_all, :destroy_by, :delete_by,
+      :destroy, :destroy_all, :delete, :delete_all, :update_all, :touch_all, :destroy_by, :delete_by,
       :find_each, :find_in_batches, :in_batches,
-      :select, :reselect, :order, :in_order_of, :reorder, :group, :limit, :offset, :joins, :left_joins, :left_outer_joins,
+      :select, :reselect, :order, :regroup, :in_order_of, :reorder, :group, :limit, :offset, :joins, :left_joins, :left_outer_joins,
       :where, :rewhere, :invert_where, :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, :excluding, :without
+      :pluck, :pick, :ids, :async_ids, :strict_loading, :excluding, :without, :with, :with_recursive,
+      :async_count, :async_average, :async_minimum, :async_maximum, :async_sum, :async_pluck, :async_pick,
+      :insert, :insert_all, :insert!, :insert_all!, :upsert, :upsert_all
     ].freeze # :nodoc:
     delegate(*QUERYING_METHODS, to: :all)
 
@@ -39,19 +41,33 @@ module ActiveRecord
     #   Post.find_by_sql "SELECT p.title, c.author FROM posts p, comments c WHERE p.id = c.post_id"
     #   # => [#<Post:0x36bff9c @attributes={"title"=>"Ruby Meetup", "author"=>"Quentin"}>, ...]
     #
-    # You can use the same string replacement techniques as you can with <tt>ActiveRecord::QueryMethods#where</tt>:
+    # You can use the same string replacement techniques as you can with ActiveRecord::QueryMethods#where :
     #
     #   Post.find_by_sql ["SELECT title FROM posts WHERE author = ? AND created > ?", author_id, start_date]
     #   Post.find_by_sql ["SELECT body FROM comments WHERE author = :user_id OR approved_by = :user_id", { :user_id => user_id }]
     #
     # Note that building your own SQL query string from user input may expose your application to
     # injection attacks (https://guides.rubyonrails.org/security.html#sql-injection).
-    def find_by_sql(sql, binds = [], preparable: nil, &block)
-      _load_from_sql(_query_by_sql(sql, binds, preparable: preparable), &block)
+    def find_by_sql(sql, binds = [], preparable: nil, allow_retry: false, &block)
+      result = with_connection do |c|
+        _query_by_sql(c, sql, binds, preparable: preparable, allow_retry: allow_retry)
+      end
+      _load_from_sql(result, &block)
+    end
+
+    # Same as <tt>#find_by_sql</tt> but perform the query asynchronously and returns an ActiveRecord::Promise.
+    def async_find_by_sql(sql, binds = [], preparable: nil, &block)
+      result = with_connection do |c|
+        _query_by_sql(c, sql, binds, preparable: preparable, async: true)
+      end
+
+      result.then do |result|
+        _load_from_sql(result, &block)
+      end
     end
 
-    def _query_by_sql(sql, binds = [], preparable: nil, async: false) # :nodoc:
-      connection.select_all(sanitize_sql(sql), "#{name} Load", binds, preparable: preparable, async: async)
+    def _query_by_sql(connection, sql, binds = [], preparable: nil, async: false, allow_retry: false) # :nodoc:
+      connection.select_all(sanitize_sql(sql), "#{name} Load", binds, preparable: preparable, async: async, allow_retry: allow_retry)
     end
 
     def _load_from_sql(result_set, &block) # :nodoc:
@@ -91,7 +107,16 @@ module ActiveRecord
     #
     # * +sql+ - An SQL statement which should return a count query from the database, see the example above.
     def count_by_sql(sql)
-      connection.select_value(sanitize_sql(sql), "#{name} Count").to_i
+      with_connection do |c|
+        c.select_value(sanitize_sql(sql), "#{name} Count").to_i
+      end
+    end
+
+    # Same as <tt>#count_by_sql</tt> but perform the query asynchronously and returns an ActiveRecord::Promise.
+    def async_count_by_sql(sql)
+      with_connection do |c|
+        c.select_value(sanitize_sql(sql), "#{name} Count", async: true).then(&:to_i)
+      end
     end
   end
 end