activerecord 6.1.7.10 → 7.0.0.alpha1

data/lib/active_record/query_logs.rb

@@ -0,0 +1,203 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/module/attribute_accessors_per_thread"
+
+module ActiveRecord
+  # = Active Record Query Logs
+  #
+  # Automatically tag SQL queries with runtime information.
+  #
+  # Default tags available for use:
+  #
+  # * +application+
+  # * +pid+
+  # * +socket+
+  # * +db_host+
+  # * +database+
+  #
+  # _Action Controller and Active Job tags are also defined when used in Rails:_
+  #
+  # * +controller+
+  # * +action+
+  # * +job+
+  #
+  # The tags used in a query can be configured directly:
+  #
+  #     ActiveRecord::QueryLogs.tags = [ :application, :controller, :action, :job ]
+  #
+  # or via Rails configuration:
+  #
+  #     config.active_record.query_log_tags = [ :application, :controller, :action, :job ]
+  #
+  # 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.
+  #
+  # 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 +update_context+ & +set_context+ methods.
+  #
+  # Direct updates to a context value:
+  #
+  #    ActiveRecord::QueryLogs.update_context(foo: Bar.new)
+  #
+  # Temporary updates limited to the execution of a block:
+  #
+  #    ActiveRecord::QueryLogs.set_context(foo: Bar.new) do
+  #      posts = Post.all
+  #    end
+  #
+  # 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:
+  #
+  #    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
+    thread_mattr_accessor :cached_comment, instance_accessor: false
+
+    class NullObject # :nodoc:
+      def method_missing(method, *args, &block)
+        NullObject.new
+      end
+
+      def nil?
+        true
+      end
+
+      private
+        def respond_to_missing?(method, include_private = false)
+          true
+        end
+    end
+
+    class << self
+      # Updates the context used to construct tags in the SQL comment.
+      # Resets the cached comment if <tt>cache_query_log_tags</tt> is +true+.
+      def update_context(**options)
+        context.merge!(**options.symbolize_keys)
+        self.cached_comment = nil
+      end
+
+      # Updates the context used to construct tags in the SQL comment during
+      # execution of the provided block. Resets the provided keys to their
+      # previous value once the block exits.
+      def set_context(**options)
+        keys = options.keys
+        previous_context = keys.zip(context.values_at(*keys)).to_h
+        update_context(**options)
+        yield if block_given?
+      ensure
+        update_context(**previous_context)
+      end
+
+      # Temporarily tag any query executed within `&block`. Can be nested.
+      def with_tag(tag, &block)
+        inline_tags.push(tag)
+        yield if block_given?
+      ensure
+        inline_tags.pop
+      end
+
+      def call(sql) # :nodoc:
+        parts = self.comments
+        if prepend_comment
+          parts << sql
+        else
+          parts.unshift(sql)
+        end
+        parts.join(" ")
+      end
+
+      private
+        # Returns an array of comments which need to be added to the query, comprised
+        # of configured and inline tags.
+        def comments
+          [ comment, inline_comment ].compact
+        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
+          if cache_query_log_tags
+            self.cached_comment ||= uncached_comment
+          else
+            uncached_comment
+          end
+        end
+
+        def uncached_comment
+          content = tag_content
+          if content.present?
+            "/*#{escape_sql_comment(content)}*/"
+          end
+        end
+
+        # Returns a +String+ containing any inline comments from +with_tag+.
+        def inline_comment
+          return nil unless inline_tags.present?
+          "/*#{escape_sql_comment(inline_tag_content)}*/"
+        end
+
+        # Return the set of active inline tags from +with_tag+.
+        def inline_tags
+          if context[:inline_tags].nil?
+            context[:inline_tags] = []
+          else
+            context[:inline_tags]
+          end
+        end
+
+        def context
+          Thread.current[:active_record_query_log_tags_context] ||= Hash.new { NullObject.new }
+        end
+
+        def escape_sql_comment(content)
+          content.to_s.gsub(%r{ (/ (?: | \g<1>) \*) \+? \s* | \s* (\* (?: | \g<2>) /) }x, "")
+        end
+
+        def tag_content
+          tags.flat_map { |i| [*i] }.filter_map do |tag|
+            key, handler = tag
+            handler ||= taggings[key]
+
+            val = if handler.nil?
+              context[key]
+            elsif handler.respond_to?(:call)
+              if handler.arity == 0
+                handler.call
+              else
+                handler.call(context)
+              end
+            else
+              handler
+            end
+            "#{key}:#{val}" unless val.nil?
+          end.join(",")
+        end
+
+        def inline_tag_content
+          inline_tags.join
+        end
+    end
+  end
+end

data/lib/active_record/querying.rb

@@ -3,7 +3,7 @@
 module ActiveRecord
   module Querying
     QUERYING_METHODS = [
-      :find, :find_by, :find_by!, :take, :take!, :first, :first!, :last, :last!,
+      :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?,
@@ -12,12 +12,12 @@ module ActiveRecord
       :create_or_find_by, :create_or_find_by!,
       :destroy_all, :delete_all, :update_all, :touch_all, :destroy_by, :delete_by,
       :find_each, :find_in_batches, :in_batches,
-      :select, :reselect, :order, :reorder, :group, :limit, :offset, :joins, :left_joins, :left_outer_joins,
-      :where, :rewhere, :preload, :extract_associated, :eager_load, :includes, :from, :lock, :readonly,
+      :select, :reselect, :order, :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
+      :pluck, :pick, :ids, :strict_loading, :excluding, :without
     ].freeze # :nodoc:
     delegate(*QUERYING_METHODS, to: :all)
 
@@ -43,8 +43,18 @@ module ActiveRecord
     #
     #   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)
-      result_set = connection.select_all(sanitize_sql(sql), "#{name} Load", binds, preparable: preparable)
+      _load_from_sql(_query_by_sql(sql, binds, preparable: preparable), &block)
+    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)
+    end
+
+    def _load_from_sql(result_set, &block) # :nodoc:
       column_types = result_set.column_types
 
       unless column_types.empty?

data/lib/active_record/railtie.rb

@@ -15,6 +15,7 @@ module ActiveRecord
   # = Active Record Railtie
   class Railtie < Rails::Railtie # :nodoc:
     config.active_record = ActiveSupport::OrderedOptions.new
+    config.active_record.encryption = ActiveSupport::OrderedOptions.new
 
     config.app_generators.orm :active_record, migration: true,
                                               timestamps: true
@@ -30,6 +31,10 @@ module ActiveRecord
     config.active_record.check_schema_cache_dump_version = true
     config.active_record.maintain_test_schema = true
     config.active_record.has_many_inversing = false
+    config.active_record.sqlite3_production_warning = true
+    config.active_record.query_log_tags_enabled = false
+    config.active_record.query_log_tags = [ :application ]
+    config.active_record.cache_query_log_tags = false
 
     config.active_record.queues = ActiveSupport::InheritableOptions.new
 
@@ -60,7 +65,7 @@ module ActiveRecord
         console.level = Rails.logger.level
         Rails.logger.extend ActiveSupport::Logger.broadcast console
       end
-      ActiveRecord::Base.verbose_query_logs = false
+      ActiveRecord.verbose_query_logs = false
     end
 
     runner do
@@ -70,7 +75,6 @@ module ActiveRecord
     initializer "active_record.initialize_timezone" do
       ActiveSupport.on_load(:active_record) do
         self.time_zone_aware_attributes = true
-        self.default_timezone = :utc
       end
     end
 
@@ -83,7 +87,7 @@ module ActiveRecord
     end
 
     initializer "active_record.migration_error" do |app|
-      if config.active_record.delete(:migration_error) == :page_load
+      if config.active_record.migration_error == :page_load
         config.app_middleware.insert_after ::ActionDispatch::Callbacks,
           ActiveRecord::Migration::CheckPending,
           file_watcher: app.config.file_watcher
@@ -91,9 +95,9 @@ module ActiveRecord
     end
 
     initializer "active_record.database_selector" do
-      if options = config.active_record.delete(:database_selector)
-        resolver = config.active_record.delete(:database_resolver)
-        operations = config.active_record.delete(:database_resolver_context)
+      if options = config.active_record.database_selector
+        resolver = config.active_record.database_resolver
+        operations = config.active_record.database_resolver_context
         config.app_middleware.use ActiveRecord::Middleware::DatabaseSelector, resolver, operations, options
       end
     end
@@ -124,9 +128,9 @@ To keep using the current cache store, you can turn off cache versioning entirel
     end
 
     initializer "active_record.check_schema_cache_dump" do
-      check_schema_cache_dump_version = config.active_record.delete(:check_schema_cache_dump_version)
+      check_schema_cache_dump_version = config.active_record.check_schema_cache_dump_version
 
-      if config.active_record.delete(:use_schema_cache_dump)
+      if config.active_record.use_schema_cache_dump
         config.after_initialize do |app|
           ActiveSupport.on_load(:active_record) do
             db_config = ActiveRecord::Base.configurations.configs_for(env_name: Rails.env).first
@@ -149,11 +153,12 @@ To keep using the current cache store, you can turn off cache versioning entirel
               next if current_version.nil?
 
               if cache.version != current_version
-                warn "Ignoring #{filename} because it has expired. The current schema version is #{current_version}, but the one in the cache is #{cache.version}."
+                warn "Ignoring #{filename} because it has expired. The current schema version is #{current_version}, but the one in the schema cache file is #{cache.version}."
                 next
               end
             end
 
+            Rails.logger.info("Using schema cache file #{filename}")
             connection_pool.set_schema_cache(cache)
           end
         end
@@ -166,10 +171,6 @@ To keep using the current cache store, you can turn off cache versioning entirel
           if app.config.eager_load
             begin
               descendants.each do |model|
-                # SchemaMigration and InternalMetadata both override `table_exists?`
-                # to bypass the schema cache, so skip them to avoid the extra queries.
-                next if model._internal?
-
                 # If the schema cache was loaded from a dump, we can use it without connecting
                 schema_cache = model.connection_pool.schema_cache
 
@@ -201,12 +202,56 @@ To keep using the current cache store, you can turn off cache versioning entirel
       end
     end
 
+    SQLITE3_PRODUCTION_WARN = "You are running SQLite in production, this is generally not recommended."\
+      " You can disable this warning by setting \"config.active_record.sqlite3_production_warning=false\"."
+    initializer "active_record.sqlite3_production_warning" do
+      if config.active_record.sqlite3_production_warning && Rails.env.production?
+        ActiveSupport.on_load(:active_record_sqlite3adapter) do
+          Rails.logger.warn(SQLITE3_PRODUCTION_WARN)
+        end
+      end
+    end
+
     initializer "active_record.set_configs" do |app|
+      configs = app.config.active_record
+
+      config.after_initialize do
+        configs.each do |k, v|
+          next if k == :encryption
+          setter = "#{k}="
+          if ActiveRecord.respond_to?(setter)
+            ActiveRecord.send(setter, v)
+          end
+        end
+      end
+
       ActiveSupport.on_load(:active_record) do
-        configs = app.config.active_record
+        # Configs used in other initializers
+        configs = configs.except(
+          :migration_error,
+          :database_selector,
+          :database_resolver,
+          :database_resolver_context,
+          :query_log_tags_enabled,
+          :query_log_tags,
+          :cache_query_log_tags,
+          :sqlite3_production_warning,
+          :check_schema_cache_dump_version,
+          :use_schema_cache_dump
+        )
 
         configs.each do |k, v|
-          send "#{k}=", v
+          next if k == :encryption
+          setter = "#{k}="
+          # Some existing initializers might rely on Active Record configuration
+          # being copied from the config object to their actual destination when
+          # `ActiveRecord::Base` is loaded.
+          # So to preserve backward compatibility we copy the config a second time.
+          if ActiveRecord.respond_to?(setter)
+            ActiveRecord.send(setter, v)
+          else
+            send(setter, v)
+          end
         end
       end
     end
@@ -215,10 +260,11 @@ To keep using the current cache store, you can turn off cache versioning entirel
     # and then establishes the connection.
     initializer "active_record.initialize_database" do
       ActiveSupport.on_load(:active_record) do
-        if ActiveRecord::Base.legacy_connection_handling
-          self.connection_handlers = { writing_role => ActiveRecord::Base.default_connection_handler }
+        if ActiveRecord.legacy_connection_handling
+          self.connection_handlers = { ActiveRecord.writing_role => ActiveRecord::Base.default_connection_handler }
         end
         self.configurations = Rails.application.config.database_configuration
+
         establish_connection
       end
     end
@@ -244,6 +290,7 @@ To keep using the current cache store, you can turn off cache versioning entirel
 
     initializer "active_record.set_executor_hooks" do
       ActiveRecord::QueryCache.install_executor_hooks
+      ActiveRecord::AsynchronousQueriesTracker.install_executor_hooks
     end
 
     initializer "active_record.add_watchable_files" do |app|
@@ -279,5 +326,58 @@ To keep using the current cache store, you can turn off cache versioning entirel
         self.signed_id_verifier_secret ||= -> { Rails.application.key_generator.generate_key("active_record/signed_id") }
       end
     end
+
+    initializer "active_record_encryption.configuration" do |app|
+      ActiveRecord::Encryption.configure \
+         primary_key: app.credentials.dig(:active_record_encryption, :primary_key),
+         deterministic_key: app.credentials.dig(:active_record_encryption, :deterministic_key),
+         key_derivation_salt: app.credentials.dig(:active_record_encryption, :key_derivation_salt),
+         **config.active_record.encryption
+
+      ActiveSupport.on_load(:active_record) do
+        # Support extended queries for deterministic attributes and validations
+        if ActiveRecord::Encryption.config.extend_queries
+          ActiveRecord::Encryption::ExtendedDeterministicQueries.install_support
+          ActiveRecord::Encryption::ExtendedDeterministicUniquenessValidator.install_support
+        end
+      end
+
+      ActiveSupport.on_load(:active_record_fixture_set) do
+        # Encrypt active record fixtures
+        if ActiveRecord::Encryption.config.encrypt_fixtures
+          ActiveRecord::Fixture.prepend ActiveRecord::Encryption::EncryptedFixtures
+        end
+      end
+
+      # Filtered params
+      ActiveSupport.on_load(:action_controller) do
+        if ActiveRecord::Encryption.config.add_to_filter_parameters
+          ActiveRecord::Encryption.install_auto_filtered_parameters(app)
+        end
+      end
+    end
+
+    initializer "active_record.query_log_tags_config" do |app|
+      config.after_initialize do
+        if app.config.active_record.query_log_tags_enabled
+          ActiveRecord.query_transformers << ActiveRecord::QueryLogs
+          ActiveRecord::QueryLogs.taggings.merge!(
+            application:  Rails.application.class.name.split("::").first,
+            pid:          -> { Process.pid },
+            socket:       -> { ActiveRecord::Base.connection_db_config.socket },
+            db_host:      -> { ActiveRecord::Base.connection_db_config.host },
+            database:     -> { ActiveRecord::Base.connection_db_config.database }
+          )
+
+          if app.config.active_record.query_log_tags.present?
+            ActiveRecord::QueryLogs.tags = app.config.active_record.query_log_tags
+          end
+
+          if app.config.active_record.cache_query_log_tags
+            ActiveRecord::QueryLogs.cache_query_log_tags = true
+          end
+        end
+      end
+    end
   end
 end

data/lib/active_record/railties/controller_runtime.rb

@@ -5,7 +5,7 @@ require "active_record/log_subscriber"
 
 module ActiveRecord
   module Railties # :nodoc:
-    module ControllerRuntime #:nodoc:
+    module ControllerRuntime # :nodoc:
       extend ActiveSupport::Concern
 
       module ClassMethods # :nodoc: