activerecord 7.0.0.rc2 → 7.0.2

data/lib/active_record/connection_adapters/sqlite3_adapter.rb

@@ -389,6 +389,34 @@ module ActiveRecord
         end
         alias column_definitions table_structure
 
+        def extract_value_from_default(default)
+          case default
+          when /^null$/i
+            nil
+          # Quoted types
+          when /^'(.*)'$/m
+            $1.gsub("''", "'")
+          # Quoted types
+          when /^"(.*)"$/m
+            $1.gsub('""', '"')
+          # Numeric types
+          when /\A-?\d+(\.\d*)?\z/
+            $&
+          else
+            # Anything else is blank or some function
+            # and we can't know the value of that, so return nil.
+            nil
+          end
+        end
+
+        def extract_default_function(default_value, default)
+          default if has_default_function?(default_value, default)
+        end
+
+        def has_default_function?(default_value, default)
+          !default_value && %r{\w+\(.*\)|CURRENT_TIME|CURRENT_DATE|CURRENT_TIMESTAMP}.match?(default)
+        end
+
         # See: https://www.sqlite.org/lang_altertable.html
         # SQLite has an additional restriction on the ALTER TABLE statement
         def invalid_alter_table_type?(type, options)

data/lib/active_record/database_configurations/connection_url_resolver.rb

@@ -2,6 +2,7 @@
 
 require "uri"
 require "active_support/core_ext/enumerable"
+require "active_support/core_ext/hash/reverse_merge"
 
 module ActiveRecord
   class DatabaseConfigurations

data/lib/active_record/database_configurations.rb

@@ -38,7 +38,7 @@ module ActiveRecord
     #   the returned list. Most of the time we're only iterating over the write
     #   connection (i.e. migrations don't need to run for the write and read connection).
     #   Defaults to +false+.
-    # * <tt>include_hidden:</tte Determines whether to include replicas and configurations
+    # * <tt>include_hidden:</tt> Determines whether to include replicas and configurations
     #   hidden by +database_tasks: false+ in the returned list. Most of the time we're only
     #   iterating over the primary connections (i.e. migrations don't need to run for the
     #   write and read connection). Defaults to +false+.

data/lib/active_record/encryption/configurable.rb

@@ -50,9 +50,9 @@ module ActiveRecord
           end
         end
 
-        def install_auto_filtered_parameters(application) # :nodoc:
+        def install_auto_filtered_parameters_hook(application) # :nodoc:
           ActiveRecord::Encryption.on_encrypted_attribute_declared do |klass, encrypted_attribute_name|
-            application.config.filter_parameters << encrypted_attribute_name unless ActiveRecord::Encryption.config.excluded_from_filter_parameters.include?(name)
+            application.config.filter_parameters << encrypted_attribute_name unless ActiveRecord::Encryption.config.excluded_from_filter_parameters.include?(encrypted_attribute_name)
           end
         end
       end

data/lib/active_record/encryption/encryptable_record.rb

@@ -37,7 +37,7 @@ module ActiveRecord
         #   in preserving it.
         # * <tt>:ignore_case</tt> - When true, it behaves like +:downcase+ but, it also preserves the original case in a specially
         #   designated column +original_<name>+. When reading the encrypted content, the version with the original case is
-        #   server. But you can still execute queries that will ignore the case. This option can only be used when +:deterministic+
+        #   served. But you can still execute queries that will ignore the case. This option can only be used when +:deterministic+
         #   is true.
         # * <tt>:context_properties</tt> - Additional properties that will override +Context+ settings when this attribute is
         #   encrypted and decrypted. E.g: +encryptor:+, +cipher:+, +message_serializer:+, etc.

data/lib/active_record/encryption/extended_deterministic_queries.rb

@@ -1,35 +1,35 @@
 # frozen_string_literal: true
 
-# Automatically expand encrypted arguments to support querying both encrypted and unencrypted data
-#
-# Active Record Encryption supports querying the db using deterministic attributes. For example:
-#
-#   Contact.find_by(email_address: "jorge@hey.com")
-#
-# The value "jorge@hey.com" will get encrypted automatically to perform the query. But there is
-# a problem while the data is being encrypted. This won't work. During that time, you need these
-# queries to be:
-#
-#   Contact.find_by(email_address: [ "jorge@hey.com", "<encrypted jorge@hey.com>" ])
-#
-# This patches ActiveRecord to support this automatically. It addresses both:
-#
-# * ActiveRecord::Base: Used in +Contact.find_by_email_address(...)+
-# * ActiveRecord::Relation: Used in +Contact.internal.find_by_email_address(...)+
-#
-# +ActiveRecord::Base+ relies on +ActiveRecord::Relation+ (+ActiveRecord::QueryMethods+) but it does
-# some prepared statements caching. That's why we need to intercept +ActiveRecord::Base+ as soon
-# as it's invoked (so that the proper prepared statement is cached).
-#
-# When modifying this file run performance tests in +test/performance/extended_deterministic_queries_performance_test.rb+ to
-#   make sure performance overhead is acceptable.
-#
-# We will extend this to support previous "encryption context" versions in future iterations
-#
-# @TODO Experimental. Support for every kind of query is pending
-# @TODO It should not patch anything if not needed (no previous schemes or no support for previous encryption schemes)
 module ActiveRecord
   module Encryption
+    # Automatically expand encrypted arguments to support querying both encrypted and unencrypted data
+    #
+    # Active Record Encryption supports querying the db using deterministic attributes. For example:
+    #
+    #   Contact.find_by(email_address: "jorge@hey.com")
+    #
+    # The value "jorge@hey.com" will get encrypted automatically to perform the query. But there is
+    # a problem while the data is being encrypted. This won't work. During that time, you need these
+    # queries to be:
+    #
+    #   Contact.find_by(email_address: [ "jorge@hey.com", "<encrypted jorge@hey.com>" ])
+    #
+    # This patches ActiveRecord to support this automatically. It addresses both:
+    #
+    # * ActiveRecord::Base: Used in +Contact.find_by_email_address(...)+
+    # * ActiveRecord::Relation: Used in +Contact.internal.find_by_email_address(...)+
+    #
+    # +ActiveRecord::Base+ relies on +ActiveRecord::Relation+ (+ActiveRecord::QueryMethods+) but it does
+    # some prepared statements caching. That's why we need to intercept +ActiveRecord::Base+ as soon
+    # as it's invoked (so that the proper prepared statement is cached).
+    #
+    # When modifying this file run performance tests in +test/performance/extended_deterministic_queries_performance_test.rb+ to
+    #   make sure performance overhead is acceptable.
+    #
+    # We will extend this to support previous "encryption context" versions in future iterations
+    #
+    # @TODO Experimental. Support for every kind of query is pending
+    # @TODO It should not patch anything if not needed (no previous schemes or no support for previous encryption schemes)
     module ExtendedDeterministicQueries
       def self.install_support
         ActiveRecord::Relation.prepend(RelationQueries)

data/lib/active_record/fixtures.rb

@@ -407,7 +407,7 @@ module ActiveRecord
   # defaults:
   #
   #   DEFAULTS: &DEFAULTS
-  #     created_on: <%= 3.weeks.ago.to_formatted_s(:db) %>
+  #     created_on: <%= 3.weeks.ago.to_fs(:db) %>
   #
   #   first:
   #     name: Smurf

data/lib/active_record/gem_version.rb

@@ -9,8 +9,8 @@ module ActiveRecord
   module VERSION
     MAJOR = 7
     MINOR = 0
-    TINY  = 0
-    PRE   = "rc2"
+    TINY  = 2
+    PRE   = nil
 
     STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")
   end

data/lib/active_record/integration.rb

@@ -79,7 +79,7 @@ module ActiveRecord
           timestamp = max_updated_column_timestamp
 
           if timestamp
-            timestamp = timestamp.utc.to_formatted_s(cache_timestamp_format)
+            timestamp = timestamp.utc.to_fs(cache_timestamp_format)
             "#{model_name.cache_key}/#{id}-#{timestamp}"
           else
             "#{model_name.cache_key}/#{id}"
@@ -103,7 +103,7 @@ module ActiveRecord
           raw_timestamp_to_cache_version(timestamp)
 
         elsif timestamp = updated_at
-          timestamp.utc.to_formatted_s(cache_timestamp_format)
+          timestamp.utc.to_fs(cache_timestamp_format)
         end
       elsif self.class.has_attribute?("updated_at")
         raise ActiveModel::MissingAttributeError, "missing attribute: updated_at"

data/lib/active_record/migration/compatibility.rb

@@ -92,6 +92,22 @@ module ActiveRecord
           end
         end
 
+        module SQLite3
+          module TableDefinition
+            def references(*args, **options)
+              args.each do |ref_name|
+                ReferenceDefinition.new(ref_name, type: :integer, **options).add_to(self)
+              end
+            end
+            alias :belongs_to :references
+
+            def column(name, type, index: nil, **options)
+              options[:precision] ||= nil
+              super
+            end
+          end
+        end
+
         module TableDefinition
           def references(*args, **options)
             args.each do |ref_name|
@@ -131,8 +147,13 @@ module ActiveRecord
         end
 
         def add_reference(table_name, ref_name, **options)
-          ReferenceDefinition.new(ref_name, **options)
-            .add_to(connection.update_table_definition(table_name, self))
+          if connection.adapter_name == "SQLite"
+            reference_definition = ReferenceDefinition.new(ref_name, type: :integer, **options)
+          else
+            reference_definition = ReferenceDefinition.new(ref_name, **options)
+          end
+
+          reference_definition.add_to(connection.update_table_definition(table_name, self))
         end
         alias :add_belongs_to :add_reference
 
@@ -140,6 +161,7 @@ module ActiveRecord
           def compatible_table_definition(t)
             class << t
               prepend TableDefinition
+              prepend SQLite3::TableDefinition
             end
             t
           end

data/lib/active_record/migration.rb

@@ -1080,7 +1080,7 @@ module ActiveRecord
     # 0 then an empty array will be returned and no migrations
     # will be run.
     #
-    # If the +current_version+ in the schema is less than
+    # If the +current_version+ in the schema is greater than
     # the +target_version+, then +down+ will be run.
     #
     # If none of the conditions are met, +up+ will be run with

data/lib/active_record/railtie.rb

@@ -360,9 +360,9 @@ To keep using the current cache store, you can turn off cache versioning entirel
       end
 
       # Filtered params
-      ActiveSupport.on_load(:action_controller) do
+      ActiveSupport.on_load(:action_controller, run_once: true) do
         if ActiveRecord::Encryption.config.add_to_filter_parameters
-          ActiveRecord::Encryption.install_auto_filtered_parameters(app)
+          ActiveRecord::Encryption.install_auto_filtered_parameters_hook(app)
         end
       end
     end

data/lib/active_record/reflection.rb

@@ -1031,7 +1031,7 @@ module ActiveRecord
       end
 
       def join_scopes(table, predicate_builder, klass = self.klass, record = nil) # :nodoc:
-        scopes = @previous_reflection.join_scopes(table, predicate_builder, record) + super
+        scopes = @previous_reflection.join_scopes(table, predicate_builder, klass, record) + super
         scopes << build_scope(table, predicate_builder, klass).instance_exec(record, &source_type_scope)
       end
 

data/lib/active_record/relation/calculations.rb

@@ -155,7 +155,7 @@ module ActiveRecord
     end
 
     # Use #pluck as a shortcut to select one or more attributes without
-    # loading a bunch of records just to grab the attributes you want.
+    # loading an entire record object per row.
     #
     #   Person.pluck(:name)
     #
@@ -345,12 +345,13 @@ module ActiveRecord
         column = aggregate_column(column_name)
         column_alias = column_alias_for("#{operation} #{column_name.to_s.downcase}")
         select_value = operation_over_aggregate_column(column, operation, distinct)
-        select_value.as(column_alias)
+        select_value.as(connection.quote_column_name(column_alias))
 
         select_values = [select_value]
         select_values += self.select_values unless having_clause.empty?
 
         select_values.concat group_columns.map { |aliaz, field|
+          aliaz = connection.quote_column_name(aliaz)
           if field.respond_to?(:as)
             field.as(aliaz)
           else

data/lib/active_record/relation/delegation.rb

@@ -87,7 +87,7 @@ module ActiveRecord
 
     delegate :to_xml, :encode_with, :length, :each, :join,
              :[], :&, :|, :+, :-, :sample, :reverse, :rotate, :compact, :in_groups, :in_groups_of,
-             :to_sentence, :to_formatted_s, :as_json,
+             :to_sentence, :to_fs, :to_formatted_s, :as_json,
              :shuffle, :split, :slice, :index, :rindex, to: :records
 
     delegate :primary_key, :connection, to: :klass

data/lib/active_record/relation/query_methods.rb

@@ -68,7 +68,7 @@ module ActiveRecord
       #    # WHERE "authors"."id" IS NOT NULL AND "comments"."id" IS NOT NULL
       def associated(*associations)
         associations.each do |association|
-          reflection = @scope.klass._reflect_on_association(association)
+          reflection = scope_association_reflection(association)
           @scope.joins!(association)
           self.not(reflection.table_name => { reflection.association_primary_key => nil })
         end
@@ -96,13 +96,22 @@ module ActiveRecord
       #    # WHERE "authors"."id" IS NULL AND "comments"."id" IS NULL
       def missing(*associations)
         associations.each do |association|
-          reflection = @scope.klass._reflect_on_association(association)
+          reflection = scope_association_reflection(association)
           @scope.left_outer_joins!(association)
           @scope.where!(reflection.table_name => { reflection.association_primary_key => nil })
         end
 
         @scope
       end
+
+      private
+        def scope_association_reflection(association)
+          reflection = @scope.klass._reflect_on_association(association)
+          unless reflection
+            raise ArgumentError.new("An association named `:#{association}` does not exist on the model `#{@scope.name}`.")
+          end
+          reflection
+        end
     end
 
     FROZEN_EMPTY_ARRAY = [].freeze
@@ -424,18 +433,23 @@ module ActiveRecord
     # adapter this will either use a CASE statement or a built-in function.
     #
     #   User.in_order_of(:id, [1, 5, 3])
-    #   # SELECT "users".* FROM "users" ORDER BY FIELD("users"."id", 1, 5, 3)
+    #   # SELECT "users".* FROM "users"
+    #   #   ORDER BY FIELD("users"."id", 1, 5, 3)
+    #   #   WHERE "users"."id" IN (1, 5, 3)
     #
     def in_order_of(column, values)
       klass.disallow_raw_sql!([column], permit: connection.column_name_with_order_matcher)
+      return spawn.none! if values.empty?
 
       references = column_references([column])
       self.references_values |= references unless references.empty?
 
       values = values.map { |value| type_caster.type_cast_for_database(column, value) }
-      column = order_column(column.to_s) if column.is_a?(Symbol)
+      arel_column = column.is_a?(Symbol) ? order_column(column.to_s) : column
 
-      spawn.order!(connection.field_ordered_value(column, values))
+      spawn
+        .order!(connection.field_ordered_value(arel_column, values))
+        .where!(arel_column.in(values))
     end
 
     # Replaces any existing order defined on the relation with the specified order.

data/lib/active_record/relation.rb

@@ -33,7 +33,6 @@ module ActiveRecord
       @delegate_to_klass = false
       @future_result = nil
       @records = nil
-      @limited_count = nil
     end
 
     def initialize_copy(other)
@@ -389,7 +388,7 @@ module ActiveRecord
       end
 
       if timestamp
-        "#{size}-#{timestamp.utc.to_formatted_s(cache_timestamp_format)}"
+        "#{size}-#{timestamp.utc.to_fs(cache_timestamp_format)}"
       else
         "#{size}"
       end
@@ -647,6 +646,21 @@ module ActiveRecord
     # Schedule the query to be performed from a background thread pool.
     #
     #   Post.where(published: true).load_async # => #<ActiveRecord::Relation>
+    #
+    # When the +Relation+ is iterated, if the background query wasn't executed yet,
+    # it will be performed by the foreground thread.
+    #
+    # Note that {config.active_record.async_query_executor}[https://guides.rubyonrails.org/configuring.html#config-active-record-async-query-executor] must be configured
+    # for queries to actually be executed concurrently. Otherwise it defaults to
+    # executing them in the foreground.
+    #
+    # +load_async+ will also fallback to executing in the foreground in the test environment when transactional
+    # fixtures are enabled.
+    #
+    # If the query was actually executed in the background, the Active Record logs will show
+    # it by prefixing the log line with <tt>ASYNC</tt>:
+    #
+    #   ASYNC Post Load (0.0ms) (db time 2ms)  SELECT "posts".* FROM "posts" LIMIT 100
     def load_async
       return load if !connection.async_enabled?
 
@@ -699,7 +713,6 @@ module ActiveRecord
       @offsets = @take = nil
       @cache_keys = nil
       @records = nil
-      @limited_count = nil
       self
     end
 
@@ -974,7 +987,7 @@ module ActiveRecord
       end
 
       def limited_count
-        @limited_count ||= limit_value ? count : limit(2).count
+        limit_value ? count : limit(2).count
       end
   end
 end

data/lib/active_record/schema.rb

@@ -10,7 +10,7 @@ module ActiveRecord
   #
   # Usage:
   #
-  #   ActiveRecord::Schema.define do
+  #   ActiveRecord::Schema[7.0].define do
   #     create_table :authors do |t|
   #       t.string :name, null: false
   #     end
@@ -30,32 +30,47 @@ module ActiveRecord
   # ActiveRecord::Schema is only supported by database adapters that also
   # support migrations, the two features being very similar.
   class Schema < Migration::Current
-    # Eval the given block. All methods available to the current connection
-    # adapter are available within the block, so you can easily use the
-    # database definition DSL to build up your schema (
-    # {create_table}[rdoc-ref:ConnectionAdapters::SchemaStatements#create_table],
-    # {add_index}[rdoc-ref:ConnectionAdapters::SchemaStatements#add_index], etc.).
-    #
-    # The +info+ hash is optional, and if given is used to define metadata
-    # about the current schema (currently, only the schema's version):
-    #
-    #   ActiveRecord::Schema.define(version: 2038_01_19_000001) do
-    #     ...
-    #   end
-    def self.define(info = {}, &block)
-      new.define(info, &block)
-    end
+    module Definition
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        # Eval the given block. All methods available to the current connection
+        # adapter are available within the block, so you can easily use the
+        # database definition DSL to build up your schema (
+        # {create_table}[rdoc-ref:ConnectionAdapters::SchemaStatements#create_table],
+        # {add_index}[rdoc-ref:ConnectionAdapters::SchemaStatements#add_index], etc.).
+        #
+        # The +info+ hash is optional, and if given is used to define metadata
+        # about the current schema (currently, only the schema's version):
+        #
+        #   ActiveRecord::Schema[7.0].define(version: 2038_01_19_000001) do
+        #     ...
+        #   end
+        def define(info = {}, &block)
+          new.define(info, &block)
+        end
+      end
+
+      def define(info, &block) # :nodoc:
+        instance_eval(&block)
 
-    def define(info, &block) # :nodoc:
-      instance_eval(&block)
+        if info[:version].present?
+          connection.schema_migration.create_table
+          connection.assume_migrated_upto_version(info[:version])
+        end
 
-      if info[:version].present?
-        connection.schema_migration.create_table
-        connection.assume_migrated_upto_version(info[:version])
+        ActiveRecord::InternalMetadata.create_table
+        ActiveRecord::InternalMetadata[:environment] = connection.migration_context.current_environment
       end
+    end
+
+    include Definition
 
-      ActiveRecord::InternalMetadata.create_table
-      ActiveRecord::InternalMetadata[:environment] = connection.migration_context.current_environment
+    def self.[](version)
+      @class_for_version ||= {}
+      @class_for_version[version] ||= Class.new(Migration::Compatibility.find(version)) do
+        include Definition
+      end
     end
   end
 end

data/lib/active_record/schema_dumper.rb

@@ -74,22 +74,21 @@ module ActiveRecord
       end
 
       def header(stream)
-        stream.puts <<HEADER
-# This file is auto-generated from the current state of the database. Instead
-# of editing this file, please use the migrations feature of Active Record to
-# incrementally modify your database, and then regenerate this schema definition.
-#
-# This file is the source Rails uses to define your schema when running `bin/rails
-# db:schema:load`. When creating a new database, `bin/rails db:schema:load` tends to
-# be faster and is potentially less error prone than running all of your
-# migrations from scratch. Old migrations may fail to apply correctly if those
-# migrations use external dependencies or application code.
-#
-# It's strongly recommended that you check this file into your version control system.
-
-ActiveRecord::Schema.define(#{define_params}) do
-
-HEADER
+        stream.puts <<~HEADER
+          # This file is auto-generated from the current state of the database. Instead
+          # of editing this file, please use the migrations feature of Active Record to
+          # incrementally modify your database, and then regenerate this schema definition.
+          #
+          # This file is the source Rails uses to define your schema when running `bin/rails
+          # db:schema:load`. When creating a new database, `bin/rails db:schema:load` tends to
+          # be faster and is potentially less error prone than running all of your
+          # migrations from scratch. Old migrations may fail to apply correctly if those
+          # migrations use external dependencies or application code.
+          #
+          # It's strongly recommended that you check this file into your version control system.
+
+          ActiveRecord::Schema[#{ActiveRecord::Migration.current_version}].define(#{define_params}) do
+        HEADER
       end
 
       def trailer(stream)

data/lib/active_record/schema_migration.rb

@@ -41,6 +41,10 @@ module ActiveRecord
       def all_versions
         order(:version).pluck(:version)
       end
+
+      def table_exists?
+        connection.data_source_exists?(table_name)
+      end
     end
 
     def version

data/lib/active_record/tasks/database_tasks.rb

@@ -257,8 +257,12 @@ module ActiveRecord
         scope = ENV["SCOPE"]
         verbose_was, Migration.verbose = Migration.verbose, verbose?
 
-        Base.connection.migration_context.migrate(target_version || version) do |migration|
-          scope.blank? || scope == migration.scope
+        Base.connection.migration_context.migrate(target_version) do |migration|
+          if version.blank?
+            scope.blank? || scope == migration.scope
+          else
+            migration.version == version
+          end
         end.tap do |migrations_ran|
           Migration.write("No migrations ran. (using #{scope} scope)") if scope.present? && migrations_ran.empty?
         end

data/lib/active_record/tasks/postgresql_database_tasks.rb

@@ -58,7 +58,7 @@ module ActiveRecord
           end
 
         args = ["--schema-only", "--no-privileges", "--no-owner"]
-        args << "--no-comment" if connection.database_version >= 110_000
+        args << "--no-comments" if connection.database_version >= 110_000
         args.concat(["--file", filename])
 
         args.concat(Array(extra_flags)) if extra_flags

data/lib/active_record.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 #--
-# Copyright (c) 2004-2021 David Heinemeier Hansson
+# Copyright (c) 2004-2022 David Heinemeier Hansson
 #
 # Permission is hereby granted, free of charge, to any person obtaining
 # a copy of this software and associated documentation files (the

data/lib/rails/generators/active_record/multi_db/multi_db_generator.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require "rails/generators/active_record"
+
+module ActiveRecord
+  module Generators # :nodoc:
+    class MultiDbGenerator < ::Rails::Generators::Base # :nodoc:
+      source_root File.expand_path("templates", __dir__)
+
+      def create_multi_db
+        filename = "multi_db.rb"
+        template filename, "config/initializers/#{filename}"
+      end
+    end
+  end
+end

data/lib/rails/generators/active_record/multi_db/templates/multi_db.rb.tt

@@ -0,0 +1,44 @@
+# Multi-db Configuration
+#
+# This file is used for configuration settings related to multiple databases.
+#
+# Enable Database Selector
+#
+# Inserts middleware to perform automatic connection switching.
+# The `database_selector` hash is used to pass options to the DatabaseSelector
+# middleware. The `delay` is used to determine how long to wait after a write
+# to send a subsequent read to the primary.
+#
+# The `database_resolver` class is used by the middleware to determine which
+# database is appropriate to use based on the time delay.
+#
+# The `database_resolver_context` class is used by the middleware to set
+# timestamps for the last write to the primary. The resolver uses the context
+# class timestamps to determine how long to wait before reading from the
+# replica.
+#
+# By default Rails will store a last write timestamp in the session. The
+# DatabaseSelector middleware is designed as such you can define your own
+# strategy for connection switching and pass that into the middleware through
+# these configuration options.
+#
+# Rails.application.configure do
+#   config.active_record.database_selector = { delay: 2.seconds }
+#   config.active_record.database_resolver = ActiveRecord::Middleware::DatabaseSelector::Resolver
+#   config.active_record.database_resolver_context = ActiveRecord::Middleware::DatabaseSelector::Resolver::Session
+# end
+#
+# Enable Shard Selector
+#
+# Inserts middleware to perform automatic shard swapping. The `shard_selector` hash
+# can be used to pass options to the `ShardSelector` middleware. The `lock` option is
+# used to determine whether shard swapping should be prohibited for the request.
+#
+# The `shard_resolver` option is used by the middleware to determine which shard
+# to switch to. The application must provide a mechanism for finding the shard name
+# in a proc. See guides for an example.
+#
+# Rails.application.configure do
+#   config.active_record.shard_selector = { lock: true }
+#   config.active_record.shard_resolver = ->(request) { Tenant.find_by!(host: request.host).shard }
+# end