omg-activerecord 8.0.0.alpha1

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

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  # = Active Record Query Cache
+  class QueryCache
+    module ClassMethods
+      # Enable the query cache within the block if Active Record is configured.
+      # If it's not, it will execute the given block.
+      def cache(&block)
+        if connected? || !configurations.empty?
+          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
+      end
+
+      # Disable the query cache within the block if Active Record is configured.
+      # If it's not, it will execute the given 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_pool.disable_query_cache(dirties: dirties, &block)
+        else
+          yield
+        end
+      end
+    end
+
+    def self.run
+      ActiveRecord::Base.connection_handler.each_connection_pool.reject(&:query_cache_enabled).each(&:enable_query_cache!)
+    end
+
+    def self.complete(pools)
+      pools.each do |pool|
+        pool.disable_query_cache!
+        pool.clear_query_cache
+      end
+
+      ActiveRecord::Base.connection_handler.each_connection_pool do |pool|
+        pool.release_connection if pool.active_connection? && !pool.lease_connection.transaction_open?
+      end
+    end
+
+    def self.install_executor_hooks(executor = ActiveSupport::Executor)
+      executor.register_hook(self)
+    end
+  end
+end

data/lib/active_record/query_logs.rb

@@ -0,0 +1,247 @@
+# 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 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.
+  #
+  # 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 adds default tags when loaded:
+  #
+  # * +controller+
+  # * +action+
+  # * +namespaced_controller+
+  #
+  # Active Job adds default tags when loaded:
+  #
+  # * +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.
+  #
+  # Escaping is performed on the string returned, however untrusted user input should not be used.
+  #
+  # Example:
+  #
+  #     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:
+  #
+  #    ActiveRecord::QueryLogs.prepend_comment = true
+  #
+  # 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:
+  #
+  #    config.active_record.cache_query_log_tags = true
+  module QueryLogs
+    class GetKeyHandler # :nodoc:
+      def initialize(name)
+        @name = name
+      end
+
+      def call(context)
+        context[@name]
+      end
+    end
+
+    class IdentityHandler # :nodoc:
+      def initialize(value)
+        @value = value
+      end
+
+      def call(_context)
+        @value
+      end
+    end
+
+    class ZeroArityHandler # :nodoc:
+      def initialize(proc)
+        @proc = proc
+      end
+
+      def call(_context)
+        @proc.call
+      end
+    end
+
+    @taggings = {}.freeze
+    @tags = [ :application ].freeze
+    @prepend_comment = false
+    @cache_query_log_tags = false
+    @tags_formatter = false
+
+    thread_mattr_accessor :cached_comment, instance_accessor: false
+
+    class << self
+      attr_reader :tags, :taggings, :tags_formatter # :nodoc:
+      attr_accessor :prepend_comment, :cache_query_log_tags # :nodoc:
+
+      def taggings=(taggings) # :nodoc:
+        @taggings = taggings.freeze
+        @handlers = rebuild_handlers
+      end
+
+      def tags=(tags) # :nodoc:
+        @tags = tags.freeze
+        @handlers = rebuild_handlers
+      end
+
+      def tags_formatter=(format) # :nodoc:
+        @formatter = case format
+        when :legacy
+          LegacyFormatter
+        when :sqlcommenter
+          SQLCommenter
+        else
+          raise ArgumentError, "Formatter is unsupported: #{format}"
+        end
+        @tags_formatter = format
+      end
+
+      def call(sql, connection) # :nodoc:
+        comment = self.comment(connection)
+
+        if comment.blank?
+          sql
+        elsif prepend_comment
+          "#{comment} #{sql}"
+        else
+          "#{sql} #{comment}"
+        end
+      end
+
+      def clear_cache # :nodoc:
+        self.cached_comment = nil
+      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
+        def rebuild_handlers
+          handlers = []
+          @tags.each do |i|
+            if i.is_a?(Hash)
+              i.each do |k, v|
+                handlers << [k, build_handler(k, v)]
+              end
+            else
+              handlers << [i, build_handler(i)]
+            end
+          end
+          handlers.sort_by! { |(key, _)| key.to_s }
+        end
+
+        def build_handler(name, handler = nil)
+          handler ||= @taggings[name]
+          if handler.nil?
+            GetKeyHandler.new(name)
+          elsif handler.respond_to?(:call)
+            if handler.arity == 0
+              ZeroArityHandler.new(handler)
+            else
+              handler
+            end
+          else
+            IdentityHandler.new(handler)
+          end
+        end
+
+        # 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(connection)
+          if cache_query_log_tags
+            self.cached_comment ||= uncached_comment(connection)
+          else
+            uncached_comment(connection)
+          end
+        end
+
+        def uncached_comment(connection)
+          content = tag_content(connection)
+
+          if content.present?
+            "/*#{escape_sql_comment(content)}*/"
+          end
+        end
+
+        def escape_sql_comment(content)
+          # 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(connection)
+          context = ActiveSupport::ExecutionContext.to_h
+          context[:connection] ||= connection
+
+          pairs = @handlers.filter_map do |(key, handler)|
+            val = handler.call(context)
+            @formatter.format(key, val) unless val.nil?
+          end
+          @formatter.join(pairs)
+        end
+    end
+
+    @handlers = rebuild_handlers
+    self.tags_formatter = :legacy
+  end
+end

data/lib/active_record/query_logs_formatter.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module QueryLogs
+    module LegacyFormatter # :nodoc:
+      class << self
+        # Formats the key value pairs into a string.
+        def format(key, value)
+          "#{key}:#{value}"
+        end
+
+        def join(pairs)
+          pairs.join(",")
+        end
+      end
+    end
+
+    class SQLCommenter # :nodoc:
+      class << self
+        def format(key, value)
+          "#{key}='#{ERB::Util.url_encode(value)}'"
+        end
+
+        def join(pairs)
+          pairs.join(",")
+        end
+      end
+    end
+  end
+end

data/lib/active_record/querying.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Querying
+    QUERYING_METHODS = [
+      :find, :find_by, :find_by!, :take, :take!, :sole, :find_sole_by, :first, :first!, :last, :last!,
+      :second, :second!, :third, :third!, :fourth, :fourth!, :fifth, :fifth!,
+      :forty_two, :forty_two!, :third_to_last, :third_to_last!, :second_to_last, :second_to_last!,
+      :exists?, :any?, :many?, :none?, :one?,
+      :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, :destroy_all, :delete, :delete_all, :update_all, :touch_all, :destroy_by, :delete_by,
+      :find_each, :find_in_batches, :in_batches,
+      :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, :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)
+
+    # Executes a custom SQL query against your database and returns all the results. The results will
+    # be returned as an array, with the requested columns encapsulated as attributes of the model you call
+    # this method from. For example, if you call <tt>Product.find_by_sql</tt>, then the results will be returned in
+    # a +Product+ object with the attributes you specified in the SQL query.
+    #
+    # If you call a complicated SQL query which spans multiple tables, the columns specified by the
+    # SELECT will be attributes of the model, whether or not they are columns of the corresponding
+    # table.
+    #
+    # The +sql+ parameter is a full SQL query as a string. It will be called as is; there will be
+    # no database agnostic conversions performed. This should be a last resort because using
+    # database-specific terms will lock you into using that particular database engine, or require you to
+    # change your call if you switch engines.
+    #
+    #   # A simple SQL query spanning multiple tables
+    #   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 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, 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, allow_retry: false, &block)
+      with_connection do |c|
+        _query_by_sql(c, sql, binds, preparable: preparable, allow_retry: allow_retry, async: true)
+      end.then do |result|
+        _load_from_sql(result, &block)
+      end
+    end
+
+    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:
+      return [] if result_set.empty?
+
+      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 = {
+        record_count: result_set.length,
+        class_name: name
+      }
+
+      message_bus.instrument("instantiation.active_record", payload) do
+        if result_set.includes_column?(inheritance_column)
+          result_set.map { |record| instantiate(record, column_types, &block) }
+        else
+          # Instantiate a homogeneous set
+          result_set.map { |record| instantiate_instance_of(self, record, column_types, &block) }
+        end
+      end
+    end
+
+    # Returns the result of an SQL statement that should only include a COUNT(*) in the SELECT part.
+    # The use of this method should be restricted to complicated SQL queries that can't be executed
+    # using the ActiveRecord::Calculations class methods. Look into those before using this method,
+    # as it could lock you into a specific database engine or require a code change to switch
+    # database engines.
+    #
+    #   Product.count_by_sql "SELECT COUNT(*) FROM sales s, customers c WHERE s.customer_id = c.id"
+    #   # => 12
+    #
+    # ==== Parameters
+    #
+    # * +sql+ - An SQL statement which should return a count query from the database, see the example above.
+    def count_by_sql(sql)
+      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