active_record_shards 3.11.2 → 3.19.0

data/lib/active_record_shards/migration.rb

@@ -1,43 +1,50 @@
 # frozen_string_literal: true
+
 module ActiveRecord
   class Migrator
-    class << self
-      [:up, :down, :run].each do |m|
-        define_method("#{m}_with_sharding") do |*args|
-          ActiveRecord::Base.on_shard(nil) do
-            send("#{m}_without_sharding", *args)
-          end
-          ActiveRecord::Base.on_all_shards do
-            send("#{m}_without_sharding", *args)
-          end
-        end
-        alias_method :"#{m}_without_sharding", m.to_sym
-        alias_method m.to_sym, :"#{m}_with_sharding"
+    def self.shards_migration_context
+      if ActiveRecord::VERSION::MAJOR >= 6
+        ActiveRecord::MigrationContext.new(ActiveRecord::Migrator.migrations_paths, ActiveRecord::SchemaMigration)
+      elsif ActiveRecord::VERSION::STRING >= '5.2.0'
+        ActiveRecord::MigrationContext.new(ActiveRecord::Migrator.migrations_paths)
+      else
+        self
       end
+    end
 
-      def bootstrap_migrations_from_nil_shard(migrations_path, this_migration = nil)
-        migrations = nil
-        ActiveRecord::Base.on_shard(nil) do
-          migrations = ActiveRecord::Migrator.new(:up, migrations_path).migrated
-        end
+    def initialize_with_sharding(*args)
+      initialize_without_sharding(*args)
 
-        puts "inserting #{migrations.size} migrations on all shards..."
-        ActiveRecord::Base.on_all_shards do
-          migrator = ActiveRecord::Migrator.new(:up, migrations_path)
-          migrations.each do |m|
-            migrator.__send__(:record_version_state_after_migrating, m)
-          end
-          if this_migration
-            migrator.__send__(:record_version_state_after_migrating, this_migration)
-          end
+      # Rails creates the internal tables on the unsharded DB. We make them
+      # manually on the sharded DBs.
+      ActiveRecord::Base.on_all_shards do
+        ActiveRecord::SchemaMigration.create_table
+        if ActiveRecord::VERSION::MAJOR >= 5
+          ActiveRecord::InternalMetadata.create_table
         end
       end
     end
+    alias_method :initialize_without_sharding, :initialize
+    alias_method :initialize, :initialize_with_sharding
+
+    def run_with_sharding
+      ActiveRecord::Base.on_shard(nil) { run_without_sharding }
+      ActiveRecord::Base.on_all_shards { run_without_sharding }
+    end
+    alias_method :run_without_sharding, :run
+    alias_method :run, :run_with_sharding
+
+    def migrate_with_sharding
+      ActiveRecord::Base.on_shard(nil) { migrate_without_sharding }
+      ActiveRecord::Base.on_all_shards { migrate_without_sharding }
+    end
+    alias_method :migrate_without_sharding, :migrate
+    alias_method :migrate, :migrate_with_sharding
 
     # don't allow Migrator class to cache versions
     undef migrated
     def migrated
-      self.class.get_all_versions
+      self.class.shards_migration_context.get_all_versions
     end
 
     # list of pending migrations is any migrations that haven't run on all shards.
@@ -56,7 +63,7 @@ module ActiveRecord
       missing = {}
 
       collect = lambda do |shard|
-        migrated = get_all_versions
+        migrated = shards_migration_context.get_all_versions
 
         p = versions - migrated
         pending[shard] = p if p.any?
@@ -82,9 +89,6 @@ module ActiveRecordShards
     end
   end
 
-  # ok, so some 'splaining to do.  Rails 3.1 puts the migrate() method on the instance of the
-  # migration, where it should have been.  But this makes our monkey patch incompatible.
-  # So we're forced to *either* include or extend this.
   module ActualMigrationExtension
     def migrate_with_forced_shard(direction)
       if migration_shard.blank?

data/lib/active_record_shards/model.rb

@@ -6,10 +6,11 @@ module ActiveRecordShards
       if self != ActiveRecord::Base && self != base_class
         raise "You should only call not_sharded on direct descendants of ActiveRecord::Base"
       end
+
       self.sharded = false
     end
 
-    def is_sharded? # rubocop:disable Style/PredicateName
+    def is_sharded? # rubocop:disable Naming/PredicateName
       if self == ActiveRecord::Base
         sharded != false && supports_sharding?
       elsif self == base_class
@@ -23,34 +24,38 @@ module ActiveRecordShards
       end
     end
 
-    def on_slave_by_default?
+    def on_replica_by_default?
       if self == ActiveRecord::Base
         false
       else
         base = base_class
-        if base.instance_variable_defined?(:@on_slave_by_default)
-          base.instance_variable_get(:@on_slave_by_default)
+        if base.instance_variable_defined?(:@on_replica_by_default)
+          base.instance_variable_get(:@on_replica_by_default)
         end
       end
     end
+    alias_method :on_slave_by_default?, :on_replica_by_default?
 
-    def on_slave_by_default=(value)
+    def on_replica_by_default=(value)
       if self == ActiveRecord::Base
-        raise ArgumentError, "Cannot set on_slave_by_default on ActiveRecord::Base"
+        raise ArgumentError, "Cannot set on_replica_by_default on ActiveRecord::Base"
       else
-        base_class.instance_variable_set(:@on_slave_by_default, value)
+        base_class.instance_variable_set(:@on_replica_by_default, value)
       end
     end
+    alias_method :on_slave_by_default=, :on_replica_by_default=
 
     module InstanceMethods
-      def initialize_shard_and_slave
-        @from_slave = !!self.class.current_shard_selection.options[:slave]
+      def initialize_shard_and_replica
+        @from_replica = !!self.class.current_shard_selection.options[:replica]
         @from_shard = self.class.current_shard_selection.options[:shard]
       end
+      alias_method :initialize_shard_and_slave, :initialize_shard_and_replica
 
-      def from_slave?
-        @from_slave
+      def from_replica?
+        @from_replica
       end
+      alias_method :from_slave?, :from_replica?
 
       def from_shard
         @from_shard
@@ -59,7 +64,7 @@ module ActiveRecordShards
 
     def self.extended(base)
       base.send(:include, InstanceMethods)
-      base.after_initialize :initialize_shard_and_slave
+      base.after_initialize :initialize_shard_and_replica
     end
 
     private

data/lib/active_record_shards/patches-4-2.rb

@@ -1,13 +1,9 @@
 # frozen_string_literal: true
+
 require 'active_record_shards/connection_pool'
 require 'active_record_shards/connection_handler'
 require 'active_record_shards/connection_specification'
-require 'active_record_shards/schema_dumper_extension'
 
 ActiveRecordShards::ConnectionSpecification = ActiveRecord::ConnectionAdapters::ConnectionSpecification
 methods_to_override = [:establish_connection, :remove_connection, :pool_for, :pool_from_any_process_for]
 ActiveRecordShards.override_connection_handler_methods(methods_to_override)
-
-ActiveRecord::Associations::Builder::HasAndBelongsToMany.include(ActiveRecordShards::DefaultSlavePatches::Rails41HasAndBelongsToManyBuilderExtension)
-
-ActiveRecord::SchemaDumper.prepend(ActiveRecordShards::SchemaDumperExtension)

data/lib/active_record_shards/schema_dumper_extension.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module ActiveRecordShards
   module SchemaDumperExtension
     def dump(stream)
@@ -23,15 +24,15 @@ module ActiveRecordShards
     def shard_header(stream)
       define_params = @version ? "version: #{@version}" : ""
 
-      stream.puts <<HEADER
+      stream.puts <<~HEADER
 
 
-# This section generated by active_record_shards
+        # This section generated by active_record_shards
 
-ActiveRecord::Base.on_all_shards do
-ActiveRecord::Schema.define(#{define_params}) do
+        ActiveRecord::Base.on_all_shards do
+        ActiveRecord::Schema.define(#{define_params}) do
 
-HEADER
+      HEADER
     end
 
     def shard_trailer(stream)

data/lib/active_record_shards/shard_selection.rb

@@ -1,11 +1,12 @@
 # frozen_string_literal: true
+
 module ActiveRecordShards
   class ShardSelection
     NO_SHARD = :_no_shard
     cattr_accessor :default_shard
 
     def initialize
-      @on_slave = false
+      @on_replica = false
       @shard = nil
     end
 
@@ -21,17 +22,17 @@ module ActiveRecordShards
         end
       end
 
-      def shard_name(klass = nil, try_slave = true)
+      def shard_name(klass = nil, try_replica = true)
         the_shard = shard(klass)
 
         @shard_names ||= {}
         @shard_names[ActiveRecordShards.rails_env] ||= {}
         @shard_names[ActiveRecordShards.rails_env][the_shard] ||= {}
-        @shard_names[ActiveRecordShards.rails_env][the_shard][try_slave] ||= {}
-        @shard_names[ActiveRecordShards.rails_env][the_shard][try_slave][@on_slave] ||= begin
+        @shard_names[ActiveRecordShards.rails_env][the_shard][try_replica] ||= {}
+        @shard_names[ActiveRecordShards.rails_env][the_shard][try_replica][@on_replica] ||= begin
           s = ActiveRecordShards.rails_env.dup
           s << "_shard_#{the_shard}" if the_shard
-          s << "_slave"              if @on_slave && try_slave
+          s << "_replica"            if @on_replica && try_replica
           s
         end
       end
@@ -46,25 +47,24 @@ module ActiveRecordShards
         end
       end
 
-      PRIMARY = "primary".freeze
+      PRIMARY = "primary"
       def resolve_connection_name(sharded:, configurations:)
         resolved_shard = sharded ? shard : nil
-
-        if !resolved_shard && !@on_slave
-          return PRIMARY
-        end
-
-        @shard_names ||= {}
-        @shard_names[ActiveRecordShards.rails_env] ||= {}
-        @shard_names[ActiveRecordShards.rails_env][resolved_shard] ||= {}
-        @shard_names[ActiveRecordShards.rails_env][resolved_shard][@on_slave] ||= begin
-          s = ActiveRecordShards.rails_env.dup
-          s << "_shard_#{resolved_shard}" if resolved_shard
-
-          if @on_slave && configurations["#{s}_slave"] # fall back to master connection
-            s << "_slave"
+        env = ActiveRecordShards.rails_env
+
+        @connection_names ||= {}
+        @connection_names[env] ||= {}
+        @connection_names[env][resolved_shard] ||= {}
+        @connection_names[env][resolved_shard][@on_replica] ||= begin
+          name = env.dup
+          name << "_shard_#{resolved_shard}" if resolved_shard
+          if @on_replica && configurations["#{name}_replica"]
+            "#{name}_replica"
+          else
+            # ActiveRecord always names its default connection pool 'primary'
+            # while everything else is named by the configuration name
+            resolved_shard ? name : PRIMARY
           end
-          s
         end
       end
 
@@ -74,16 +74,18 @@ module ActiveRecordShards
       @shard = (new_shard || NO_SHARD)
     end
 
-    def on_slave?
-      @on_slave
+    def on_replica?
+      @on_replica
     end
+    alias_method :on_slave?, :on_replica?
 
-    def on_slave=(new_slave)
-      @on_slave = (new_slave == true)
+    def on_replica=(new_replica)
+      @on_replica = (new_replica == true)
     end
+    alias_method :on_slave=, :on_replica=
 
     def options
-      { shard: @shard, slave: @on_slave }
+      { shard: @shard, replica: @on_replica }
     end
   end
 end

data/lib/active_record_shards/shard_support.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module ActiveRecordShards
   class ShardSupport
     class ShardEnumerator

data/lib/active_record_shards/sql_comments.rb

@@ -1,16 +1,23 @@
-# show which connection was picked to debug master/slave slowness when both servers are the same
+# show which connection was picked to debug primary/replica slowness when both servers are the same
 module ActiveRecordShards
   module SqlComments
     module Methods
       def execute(query, name = nil)
-        slave = ActiveRecord::Base.current_shard_selection.on_slave?
-        query += " /* #{slave ? 'slave' : 'master'} */"
+        shard = ActiveRecord::Base.current_shard_selection.shard
+        shard_text = shard ? "shard #{shard}" : 'unsharded'
+        replica = ActiveRecord::Base.current_shard_selection.on_replica?
+        replica_text = replica ? 'replica' : 'primary'
+        query = "/* #{shard_text} #{replica_text} */ " + query
         super(query, name)
       end
     end
 
     def self.enable
-      ActiveRecord::Base.on_shard(nil) { ActiveRecord::Base.connection.class.prepend(Methods) }
+      ActiveRecord::Base.on_replica do
+        ActiveRecord::Base.on_shard(nil) do
+          ActiveRecord::Base.connection.class.prepend(Methods)
+        end
+      end
     end
   end
 end

data/lib/active_record_shards/tasks.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require 'active_record_shards'
 
 %w[db:drop db:create db:abort_if_pending_migrations db:reset db:test:purge].each do |name|
@@ -8,15 +9,16 @@ end
 namespace :db do
   desc 'Drops the database for the current RAILS_ENV including shards'
   task drop: :load_config do
-    ActiveRecord::Base.configurations.each do |key, conf|
-      next if !key.starts_with?(ActiveRecordShards.rails_env) || key.ends_with?("_slave")
+    ActiveRecord::Base.configurations.to_h.each do |key, conf|
+      next if !key.start_with?(ActiveRecordShards.rails_env) || key.end_with?("_replica", "_slave")
+
       begin
         ActiveRecordShards::Tasks.root_connection(conf).drop_database(conf['database'])
       # rescue ActiveRecord::NoDatabaseError # TODO: exists in AR but never is raised here ...
       #   $stderr.puts "Database '#{conf['database']}' does not exist"
-      rescue StandardError => error
-        $stderr.puts error, *error.backtrace
-        $stderr.puts "Couldn't drop #{conf['database']}"
+      rescue StandardError => e
+        warn e, *e.backtrace
+        warn "Couldn't drop #{conf['database']}"
       end
     end
   end
@@ -28,25 +30,22 @@ namespace :db do
 
   desc "Create the database defined in config/database.yml for the current RAILS_ENV including shards"
   task create: :load_config do
-    ActiveRecord::Base.configurations.each do |key, conf|
-      next if !key.starts_with?(ActiveRecordShards.rails_env) || key.ends_with?("_slave")
-      if ActiveRecord::VERSION::MAJOR >= 4
-        begin
-          # MysqlAdapter takes charset instead of encoding in Rails 4
-          # https://github.com/rails/rails/commit/78b30fed9336336694fb2cb5d2825f95800b541c
-          symbolized_configuration = conf.symbolize_keys
-          symbolized_configuration[:charset] = symbolized_configuration[:encoding]
+    ActiveRecord::Base.configurations.to_h.each do |key, conf|
+      next if !key.start_with?(ActiveRecordShards.rails_env) || key.end_with?("_replica", "_slave")
+
+      begin
+        # MysqlAdapter takes charset instead of encoding in Rails 4.2 or greater
+        # https://github.com/rails/rails/blob/4-2-stable/activerecord/lib/active_record/tasks/mysql_database_tasks.rb#L85-L96
+        symbolized_configuration = conf.symbolize_keys
+        symbolized_configuration[:charset] = symbolized_configuration[:encoding]
 
-          ActiveRecordShards::Tasks.root_connection(conf).create_database(conf['database'], symbolized_configuration)
-        rescue ActiveRecord::StatementInvalid => ex
-          if ex.message.include?('database exists')
-            puts "#{conf['database']} already exists"
-          else
-            raise ex
-          end
+        ActiveRecordShards::Tasks.root_connection(conf).create_database(conf['database'], symbolized_configuration)
+      rescue ActiveRecord::StatementInvalid => e
+        if e.message.include?('database exists')
+          puts "#{conf['database']} already exists"
+        else
+          raise e
         end
-      else
-        create_database(conf)
       end
     end
     ActiveRecord::Base.establish_connection(ActiveRecordShards.rails_env.to_sym)
@@ -56,16 +55,20 @@ namespace :db do
   task abort_if_pending_migrations: :environment do
     if defined? ActiveRecord
       pending_migrations =
-        if Rails::VERSION::MAJOR >= 4
-          ActiveRecord::Base.on_shard(nil) { ActiveRecord::Migrator.open(ActiveRecord::Migrator.migrations_paths).pending_migrations }
+        if ActiveRecord::VERSION::MAJOR >= 6
+          migrations = ActiveRecord::MigrationContext.new(ActiveRecord::Migrator.migrations_paths, ActiveRecord::SchemaMigration).migrations
+          ActiveRecord::Migrator.new(:up, migrations, ActiveRecord::SchemaMigration).pending_migrations
+        elsif ActiveRecord::VERSION::STRING >= "5.2.0"
+          migrations = ActiveRecord::MigrationContext.new(ActiveRecord::Migrator.migrations_paths).migrations
+          ActiveRecord::Migrator.new(:up, migrations).pending_migrations
         else
-          ActiveRecord::Base.on_shard(nil) { ActiveRecord::Migrator.new(:up, 'db/migrate').pending_migrations }
+          ActiveRecord::Base.on_shard(nil) { ActiveRecord::Migrator.open(ActiveRecord::Migrator.migrations_paths).pending_migrations }
         end
 
       if pending_migrations.any?
-        puts "You have #{pending_migrations.size} pending migrations:"
+        warn "You have #{pending_migrations.size} pending migrations:"
         pending_migrations.each do |pending_migration|
-          puts '  %4d %s' % [pending_migration.version, pending_migration.name]
+          warn '  %4d %s' % [pending_migration.version, pending_migration.name]
         end
         abort %(Run "rake db:migrate" to update your database then try again.)
       end
@@ -89,17 +92,19 @@ end
 
 module ActiveRecordShards
   module Tasks
-    if ActiveRecord::VERSION::MAJOR < 5
-      def self.root_connection(conf)
-        ActiveRecord::Base.send("#{conf['adapter']}_connection", conf.merge('database' => nil))
-      end
-    else
-      def self.root_connection(conf)
-        # this will trigger rails to load the adapter
+    class << self
+      def root_connection(conf)
         conf = conf.merge('database' => nil)
+        spec = spec_for(conf)
+
+        ActiveRecord::Base.send("#{conf['adapter']}_connection", spec.config)
+      end
+
+      private
+
+      def spec_for(conf)
         resolver = ActiveRecord::ConnectionAdapters::ConnectionSpecification::Resolver.new(ActiveRecord::Base.configurations)
         resolver.spec(conf)
-        ActiveRecord::Base.send("#{conf['adapter']}_connection", conf)
       end
     end
   end

data/lib/active_record_shards.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require 'active_record'
 require 'active_record/base'
 require 'active_record_shards/configuration_parser'
@@ -7,7 +8,8 @@ require 'active_record_shards/shard_selection'
 require 'active_record_shards/connection_switcher'
 require 'active_record_shards/association_collection_connection_selection'
 require 'active_record_shards/migration'
-require 'active_record_shards/default_slave_patches'
+require 'active_record_shards/default_replica_patches'
+require 'active_record_shards/schema_dumper_extension'
 
 module ActiveRecordShards
   def self.rails_env
@@ -21,17 +23,119 @@ end
 ActiveRecord::Base.extend(ActiveRecordShards::ConfigurationParser)
 ActiveRecord::Base.extend(ActiveRecordShards::Model)
 ActiveRecord::Base.extend(ActiveRecordShards::ConnectionSwitcher)
-ActiveRecord::Base.extend(ActiveRecordShards::DefaultSlavePatches)
-ActiveRecord::Relation.include(ActiveRecordShards::DefaultSlavePatches::ActiveRelationPatches)
+ActiveRecord::Base.extend(ActiveRecordShards::DefaultReplicaPatches)
+ActiveRecord::Relation.include(ActiveRecordShards::DefaultReplicaPatches::ActiveRelationPatches)
 ActiveRecord::Associations::CollectionProxy.include(ActiveRecordShards::AssociationCollectionConnectionSelection)
+ActiveRecord::Associations::Builder::HasAndBelongsToMany.include(ActiveRecordShards::DefaultReplicaPatches::Rails41HasAndBelongsToManyBuilderExtension)
+ActiveRecord::SchemaDumper.prepend(ActiveRecordShards::SchemaDumperExtension)
 
 case "#{ActiveRecord::VERSION::MAJOR}.#{ActiveRecord::VERSION::MINOR}"
-when '3.2'
-  require 'active_record_shards/patches-3-2'
 when '4.2'
   require 'active_record_shards/patches-4-2'
-when '5.0', '5.1'
-  require 'active_record_shards/patches-5-0'
+
+  # https://github.com/rails/rails/blob/v4.2.11.3/activerecord/lib/active_record/associations/association.rb#L97
+  ActiveRecord::Associations::Association.prepend(ActiveRecordShards::DefaultReplicaPatches::AssociationsAssociationAssociationScopePatch)
+
+  # https://github.com/rails/rails/blob/v4.2.11.3/activerecord/lib/active_record/associations/singular_association.rb#L44-L53
+  ActiveRecord::Associations::SingularAssociation.prepend(ActiveRecordShards::DefaultReplicaPatches::AssociationsAssociationGetRecordsPatch)
+
+  # https://github.com/rails/rails/blob/v4.2.11.3/activerecord/lib/active_record/associations/collection_association.rb#L447-L456
+  ActiveRecord::Associations::CollectionAssociation.prepend(ActiveRecordShards::DefaultReplicaPatches::AssociationsAssociationGetRecordsPatch)
+
+  # https://github.com/rails/rails/blob/v4.2.11.3/activerecord/lib/active_record/associations/preloader/association.rb#L89
+  ActiveRecord::Associations::Preloader::Association.prepend(ActiveRecordShards::DefaultReplicaPatches::AssociationsPreloaderAssociationAssociatedRecordsByOwnerPatch)
+when '5.0'
+  # https://github.com/rails/rails/blob/v5.0.7/activerecord/lib/active_record/associations/association.rb#L97
+  ActiveRecord::Associations::Association.prepend(ActiveRecordShards::DefaultReplicaPatches::AssociationsAssociationAssociationScopePatch)
+
+  # https://github.com/rails/rails/blob/v5.0.7/activerecord/lib/active_record/associations/singular_association.rb#L56-L65
+  ActiveRecord::Associations::SingularAssociation.prepend(ActiveRecordShards::DefaultReplicaPatches::AssociationsAssociationGetRecordsPatch)
+
+  # https://github.com/rails/rails/blob/v5.0.7/activerecord/lib/active_record/associations/collection_association.rb#L442-L451
+  ActiveRecord::Associations::CollectionAssociation.prepend(ActiveRecordShards::DefaultReplicaPatches::AssociationsAssociationGetRecordsPatch)
+
+  # https://github.com/rails/rails/blob/v5.0.7/activerecord/lib/active_record/associations/preloader/association.rb#L120
+  ActiveRecord::Associations::Preloader::Association.prepend(ActiveRecordShards::DefaultReplicaPatches::AssociationsPreloaderAssociationLoadRecordsPatch)
+when '5.1'
+  # https://github.com/rails/rails/blob/v5.1.7/activerecord/lib/active_record/associations/association.rb#L97
+  ActiveRecord::Associations::Association.prepend(ActiveRecordShards::DefaultReplicaPatches::AssociationsAssociationAssociationScopePatch)
+
+  # https://github.com/rails/rails/blob/v5.1.7/activerecord/lib/active_record/associations/singular_association.rb#L41
+  ActiveRecord::Associations::SingularAssociation.prepend(ActiveRecordShards::DefaultReplicaPatches::AssociationsAssociationFindTargetPatch)
+
+  # https://github.com/rails/rails/blob/v5.1.7/activerecord/lib/active_record/associations/collection_association.rb#L305
+  ActiveRecord::Associations::CollectionAssociation.prepend(ActiveRecordShards::DefaultReplicaPatches::AssociationsAssociationFindTargetPatch)
+
+  # https://github.com/rails/rails/blob/v5.1.7/activerecord/lib/active_record/associations/preloader/association.rb#L120
+  ActiveRecord::Associations::Preloader::Association.prepend(ActiveRecordShards::DefaultReplicaPatches::AssociationsPreloaderAssociationLoadRecordsPatch)
+when '5.2'
+  # https://github.com/rails/rails/blob/v5.2.6/activerecord/lib/active_record/relation.rb#L530
+  # But the #exec_queries method also calls #connection, and I don't know if we should patch that one, too...
+  ActiveRecord::Relation.prepend(ActiveRecordShards::DefaultReplicaPatches::Rails52RelationPatches)
+
+  # https://github.com/rails/rails/blob/v5.2.6/activerecord/lib/active_record/associations/singular_association.rb#L42
+  ActiveRecord::Associations::SingularAssociation.prepend(ActiveRecordShards::DefaultReplicaPatches::AssociationsAssociationFindTargetPatch)
+
+  # https://github.com/rails/rails/blob/v5.2.6/activerecord/lib/active_record/associations/collection_association.rb#L308
+  ActiveRecord::Associations::CollectionAssociation.prepend(ActiveRecordShards::DefaultReplicaPatches::AssociationsAssociationFindTargetPatch)
+
+  # https://github.com/rails/rails/blob/v5.2.6/activerecord/lib/active_record/associations/preloader/association.rb#L96
+  ActiveRecord::Associations::Preloader::Association.prepend(ActiveRecordShards::DefaultReplicaPatches::AssociationsPreloaderAssociationLoadRecordsPatch)
+when '6.0'
+  # https://github.com/rails/rails/blob/v6.0.4/activerecord/lib/active_record/type_caster/connection.rb#L28
+  ActiveRecord::TypeCaster::Connection.prepend(ActiveRecordShards::DefaultReplicaPatches::TypeCasterConnectionConnectionPatch)
+
+  # https://github.com/rails/rails/blob/v6.0.4/activerecord/lib/active_record/schema.rb#L53-L54
+  ActiveRecord::Schema.prepend(ActiveRecordShards::DefaultReplicaPatches::SchemaDefinePatch)
+
+  # https://github.com/rails/rails/blob/v6.0.4/activerecord/lib/active_record/relation.rb#L739
+  # But the #exec_queries and #compute_cache_version methods also call #connection, and I don't know if we should patch those, too...
+  ActiveRecord::Relation.prepend(ActiveRecordShards::DefaultReplicaPatches::Rails52RelationPatches)
+
+  # https://github.com/rails/rails/blob/v6.0.4/activerecord/lib/active_record/associations/association.rb#L213
+  ActiveRecord::Associations::Association.prepend(ActiveRecordShards::DefaultReplicaPatches::AssociationsAssociationFindTargetPatch)
 else
   raise "ActiveRecordShards is not compatible with #{ActiveRecord::VERSION::STRING}"
 end
+
+require 'active_record_shards/deprecation'
+
+ActiveRecordShards::Deprecation.deprecate_methods(
+  ActiveRecordShards::AssociationCollectionConnectionSelection,
+  on_slave_if: :on_replica_if,
+  on_slave_unless: :on_replica_unless,
+  on_slave: :on_replica,
+  on_master: :on_primary,
+  on_master_if: :on_primary_if,
+  on_master_unless: :on_primary_unless
+)
+
+ActiveRecordShards::Deprecation.deprecate_methods(
+  ActiveRecordShards::ConnectionSwitcher,
+  on_slave_if: :on_replica_if,
+  on_slave_unless: :on_replica_unless,
+  on_master_or_slave: :on_primary_or_replica,
+  on_slave: :on_replica,
+  on_master: :on_primary,
+  on_master_if: :on_primary_if,
+  on_master_unless: :on_primary_unless,
+  on_slave?: :on_replica?
+)
+
+ActiveRecordShards::Deprecation.deprecate_methods(
+  ActiveRecordShards::DefaultReplicaPatches,
+  transaction_with_slave_off: :transaction_with_replica_off,
+  on_slave_unless_tx: :on_replica_unless_tx
+)
+
+ActiveRecordShards::Deprecation.deprecate_methods(
+  ActiveRecordShards::Model,
+  on_slave_by_default?: :on_replica_by_default?,
+  :on_slave_by_default= => :on_replica_by_default=
+)
+
+ActiveRecordShards::Deprecation.deprecate_methods(
+  ActiveRecordShards::ShardSelection,
+  on_slave?: :on_replica?,
+  :on_slave= => :on_replica=
+)