omg-activerecord 8.0.0.alpha1

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

@@ -0,0 +1,319 @@
+# frozen_string_literal: true
+
+require "concurrent/map"
+require "concurrent/atomic/atomic_fixnum"
+
+module ActiveRecord
+  module ConnectionAdapters # :nodoc:
+    module QueryCache
+      DEFAULT_SIZE = 100 # :nodoc:
+
+      class << self
+        def included(base) # :nodoc:
+          dirties_query_cache base, :exec_query, :execute, :create, :insert, :update, :delete, :truncate,
+            :truncate_tables, :rollback_to_savepoint, :rollback_db_transaction, :restart_db_transaction,
+            :exec_insert_all
+
+          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}(...)
+                if pool.dirties_query_cache
+                  ActiveRecord::Base.clear_query_caches_for_current_thread
+                end
+                super
+              end
+            end_code
+          end
+        end
+      end
+
+      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_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, query_cache.dirties = true, true
+        end
+
+        def disable_query_cache!
+          query_cache.enabled, query_cache.dirties = false, true
+        end
+
+        def query_cache_enabled
+          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_accessor :query_cache
+
+      def initialize(*)
+        super
+        @query_cache = nil
+      end
+
+      def query_cache_enabled
+        @query_cache&.enabled?
+      end
+
+      # Enable the query cache within the block.
+      def cache(&block)
+        pool.enable_query_cache(&block)
+      end
+
+      def enable_query_cache!
+        pool.enable_query_cache!
+      end
+
+      # 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
+
+      def disable_query_cache!
+        pool.disable_query_cache!
+      end
+
+      # Clears the query cache.
+      #
+      # One reason you may wish to call this method explicitly is between queries
+      # that ask the database to randomize results. Otherwise the cache would see
+      # the same SQL query and repeatedly return the same result each time, silently
+      # undermining the randomness you were expecting.
+      def clear_query_cache
+        pool.clear_query_cache
+      end
+
+      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, 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, allow_retry: allow_retry)
+            FutureResult.wrap(result)
+          else
+            cache_sql(sql, name, binds) { super(sql, name, binds, preparable: preparable, async: async, allow_retry: allow_retry) }
+          end
+        else
+          super
+        end
+      end
+
+      private
+        def unset_query_cache!
+          @query_cache = nil
+        end
+
+        def lookup_sql_cache(sql, name, binds)
+          key = binds.empty? ? sql : [sql, binds]
+
+          result = nil
+          @lock.synchronize do
+            result = @query_cache[key]
+          end
+
+          if result
+            ActiveSupport::Notifications.instrument(
+              "sql.active_record",
+              cache_notification_info_result(sql, name, binds, result)
+            )
+          end
+
+          result
+        end
+
+        def cache_sql(sql, name, binds)
+          key = binds.empty? ? sql : [sql, binds]
+          result = nil
+          hit = true
+
+          @lock.synchronize do
+            result = @query_cache.compute_if_absent(key) do
+              hit = false
+              yield
+            end
+          end
+
+          if hit
+            ActiveSupport::Notifications.instrument(
+              "sql.active_record",
+              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)
+          {
+            sql: sql,
+            binds: binds,
+            type_casted_binds: -> { type_casted_binds(binds) },
+            name: name,
+            connection: self,
+            transaction: current_transaction.user_transaction.presence,
+            cached: true
+          }
+        end
+    end
+  end
+end

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

@@ -0,0 +1,239 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/big_decimal/conversions"
+require "active_support/multibyte/chars"
+
+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)
+        case value
+        when String, Symbol, ActiveSupport::Multibyte::Chars
+          "'#{quote_string(value.to_s)}'"
+        when true       then quoted_true
+        when false      then quoted_false
+        when nil        then "NULL"
+        # BigDecimals need to be put in a non-normalized form and quoted.
+        when BigDecimal then value.to_s("F")
+        when Numeric then value.to_s
+        when Type::Binary::Data then quoted_binary(value)
+        when Type::Time::Value then "'#{quoted_time(value)}'"
+        when Date, Time then "'#{quoted_date(value)}'"
+        when Class      then "'#{value}'"
+        else raise TypeError, "can't quote #{value.class.name}"
+        end
+      end
+
+      # Cast a +value+ to a type that the database understands. For example,
+      # SQLite does not understand dates, so this method will convert a Date
+      # to a String.
+      def type_cast(value)
+        case value
+        when Symbol, ActiveSupport::Multibyte::Chars, Type::Binary::Data
+          value.to_s
+        when true       then unquoted_true
+        when false      then unquoted_false
+        # BigDecimals need to be put in a non-normalized form and quoted.
+        when BigDecimal then value.to_s("F")
+        when nil, Numeric, String then value
+        when Type::Time::Value then quoted_time(value)
+        when Date, Time then quoted_date(value)
+        else raise TypeError, "can't cast #{value.class.name}"
+        end
+      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.
+      def cast_bound_value(value) # :nodoc:
+        value
+      end
+
+      # If you are having to call this function, you are likely doing something
+      # wrong. The column does not have sufficient type information if the user
+      # provided a custom type on the class level either explicitly (via
+      # Attributes::ClassMethods#attribute) or implicitly (via
+      # AttributeMethods::Serialization::ClassMethods#serialize, +time_zone_aware_attributes+).
+      # In almost all cases, the sql type should only be used to change quoting behavior, when the primitive to
+      # represent the type doesn't sufficiently reflect the differences
+      # (varchar vs binary) for example. The type used to get this primitive
+      # should have been provided before reaching the connection adapter.
+      def lookup_cast_type_from_column(column) # :nodoc:
+        lookup_cast_type(column.sql_type)
+      end
+
+      # Quotes a string, escaping any ' (single quote) and \ (backslash)
+      # characters.
+      def quote_string(s)
+        s.gsub("\\", '\&\&').gsub("'", "''") # ' (for ruby-mode)
+      end
+
+      # Quotes the column name.
+      def quote_column_name(column_name)
+        self.class.quote_column_name(column_name)
+      end
+
+      # Quotes the table name.
+      def quote_table_name(table_name)
+        self.class.quote_table_name(table_name)
+      end
+
+      # Override to return the quoted table name for assignment. Defaults to
+      # table quoting.
+      #
+      # This works for MySQL where table.column can be used to
+      # resolve ambiguity.
+      #
+      # We override this in the sqlite3 and postgresql adapters to use only
+      # the column name (as per syntax requirements).
+      def quote_table_name_for_assignment(table, attr)
+        quote_table_name("#{table}.#{attr}")
+      end
+
+      def quote_default_expression(value, column) # :nodoc:
+        if value.is_a?(Proc)
+          value.call
+        else
+          value = lookup_cast_type(column.sql_type).serialize(value)
+          quote(value)
+        end
+      end
+
+      def quoted_true
+        "TRUE"
+      end
+
+      def unquoted_true
+        true
+      end
+
+      def quoted_false
+        "FALSE"
+      end
+
+      def unquoted_false
+        false
+      end
+
+      # Quote date/time values for use in SQL input. Includes microseconds
+      # if the value is a Time responding to usec.
+      def quoted_date(value)
+        if value.acts_like?(:time)
+          if default_timezone == :utc
+            value = value.getutc if !value.utc?
+          else
+            value = value.getlocal
+          end
+        end
+
+        result = value.to_fs(:db)
+        if value.respond_to?(:usec) && value.usec > 0
+          result << "." << sprintf("%06d", value.usec)
+        else
+          result
+        end
+      end
+
+      def quoted_time(value) # :nodoc:
+        value = value.change(year: 2000, month: 1, day: 1)
+        quoted_date(value).sub(/\A\d\d\d\d-\d\d-\d\d /, "")
+      end
+
+      def quoted_binary(value) # :nodoc:
+        "'#{quote_string(value.to_s)}'"
+      end
+
+      def sanitize_as_sql_comment(value) # :nodoc:
+        # Sanitize a string to appear within a SQL comment
+        # For compatibility, this also surrounding "/*+", "/*", and "*/"
+        # charcacters, possibly with single surrounding space.
+        # Then follows that by replacing any internal "*/" or "/ *" with
+        # "* /" or "/ *"
+        comment = value.to_s.dup
+        comment.gsub!(%r{\A\s*/\*\+?\s?|\s?\*/\s*\Z}, "")
+        comment.gsub!("*/", "* /")
+        comment.gsub!("/*", "/ *")
+        comment
+      end
+
+      private
+        def type_casted_binds(binds)
+          binds&.map do |value|
+            if ActiveModel::Attribute === value
+              type_cast(value.value_for_database)
+            else
+              type_cast(value)
+            end
+          end
+        end
+
+        def lookup_cast_type(sql_type)
+          type_map.lookup(sql_type)
+        end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    # = Active Record Connection Adapters \Savepoints
+    module Savepoints
+      def current_savepoint_name
+        current_transaction.savepoint_name
+      end
+
+      def create_savepoint(name = current_savepoint_name)
+        internal_execute("SAVEPOINT #{name}", "TRANSACTION")
+      end
+
+      def exec_rollback_to_savepoint(name = current_savepoint_name)
+        internal_execute("ROLLBACK TO SAVEPOINT #{name}", "TRANSACTION")
+      end
+
+      def release_savepoint(name = current_savepoint_name)
+        internal_execute("RELEASE SAVEPOINT #{name}", "TRANSACTION")
+      end
+    end
+  end
+end