active_record_shards 3.21.0 → 5.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: aadf0c3e7681201dfc6b2f9ff1c9a33164d7e9b17394052e09601f807926c73a
-  data.tar.gz: 3e1eaac98dbcdeb6133787447fdd4a7c56aa4056013e9b01aa2082f00a6bc733
+  metadata.gz: 032e2279ef2f82d2a1a30a171429a7b34b625766fe3a6060ad21141d551c0ca4
+  data.tar.gz: 169c3f8e0bf7d4f036a23106d8523b5e09756535f289be4da5ec295ec6c1605d
 SHA512:
-  metadata.gz: eecd43504f6dcb074c97128d96a2b5bbeeea08bc92e6c005bc3b8d3952670ea7a201856709b50c0ad5e4d91db1eb9aac9bba02762a424eaa3a23bb44c00fbdbd
-  data.tar.gz: 1f91bc255828d9bae15bf5267a5a836049e12eef663751dbad63de1f35e84cea566f071f290db96f84accc4bb20c2d52c82cbedbe79a6bc637769cae7aeafa75
+  metadata.gz: c35a082c7b33926009467f10871177ecb02a2c5dc3b009a1f5d1a889fb49f039ea88bb931cdd80c7cc67763120158748610925ece6d53ee463020388a4690cc5
+  data.tar.gz: 4acc42ae93f573d60d12384f6f7454b4a85d1a5a13239491cb6b00a10d722dfb1534026119f845b3f8c39c5e0114500099eac6806cc2c8b6864c7c9f74835fde

data/README.md

@@ -5,7 +5,9 @@
 ActiveRecord Shards is an extension for ActiveRecord that provides support for sharded database and replicas. Basically it is just a nice way to
 switch between database connections. We've made the implementation very small, and have tried not to reinvent any wheels already present in ActiveRecord.
 
-ActiveRecord Shards has been used and tested on Rails 4.2, 5.x and 6.0, and has in some form or another been used in production on large Rails apps for several years.
+ActiveRecord Shards has been used and tested on Rails 5.x and 6.0, and has in some form or another been used in production on large Rails apps for several years.
+
+Rails 6.1 introduced new connection handling and support for sharding. Apps are encouraged to migrate to the native sharding logic but ActiveRecord Shards supports Rails 6.1 when `legacy_connection_handling` is set to `true`. For more information see [Rails 6.1 installation](#rails-61-installation) and Rails' [multiple databases guide](https://guides.rubyonrails.org/active_record_multiple_databases.html).
 
 - [Installation](#installation)
 - [Configuration](#configuration)
@@ -22,6 +24,22 @@ ActiveRecord Shards has been used and tested on Rails 4.2, 5.x and 6.0, and has
 
 and make sure to require 'active\_record\_shards' in some way.
 
+### Rails 6.1 & 7.0 installation
+
+Rails 6.1 & 7.0 are **only** supported with `legacy_connection_handling` set to `true`.
+
+Enable the legacy handling in your configuration files e.g. `config/application.rb` by setting:
+
+``` Ruby
+config.active_record.legacy_connection_handling = true
+```
+
+or
+
+``` Ruby
+ActiveRecord::Base.legacy_connection_handling = true
+```
+
 ## Configuration
 
 Add the replica and shard configuration to config/database.yml:

data/lib/active_record_shards/association_collection_connection_selection.rb

@@ -5,32 +5,26 @@ module ActiveRecordShards
     def on_replica_if(condition)
       condition ? on_replica : self
     end
-    alias_method :on_slave_if, :on_replica_if
 
     def on_replica_unless(condition)
       on_replica_if(!condition)
     end
-    alias_method :on_slave_unless, :on_replica_unless
 
     def on_primary_if(condition)
       condition ? on_primary : self
     end
-    alias_method :on_master_if, :on_primary_if
 
     def on_primary_unless(condition)
       on_primary_if(!condition)
     end
-    alias_method :on_master_unless, :on_primary_unless
 
     def on_replica
       PrimaryReplicaProxy.new(self, :replica)
     end
-    alias_method :on_slave, :on_replica
 
     def on_primary
       PrimaryReplicaProxy.new(self, :primary)
     end
-    alias_method :on_master, :on_primary
 
     class PrimaryReplicaProxy
       def initialize(association_collection, which)
@@ -42,8 +36,7 @@ module ActiveRecordShards
         reflection = @association_collection.proxy_association.reflection
         reflection.klass.on_cx_switch_block(@which) { @association_collection.send(method, *args, &block) }
       end
+      ruby2_keywords(:method_missing) if respond_to?(:ruby2_keywords, true)
     end
-
-    MasterSlaveProxy = PrimaryReplicaProxy
   end
 end

data/lib/active_record_shards/configuration_parser.rb

@@ -28,27 +28,6 @@ module ActiveRecordShards
           expand_child!(env_config, replica_conf)
           conf["#{env_name}_replica"] = replica_conf
         end
-
-        # rubocop:disable Style/Next
-        if legacy_replica_conf = env_config.delete('slave')
-          ActiveRecordShards::Deprecation.warn('`slave` configuration keys should be replaced with `replica` keys!')
-          expand_child!(env_config, legacy_replica_conf)
-          conf["#{env_name}_replica"] = legacy_replica_conf
-        end
-        # rubocop:enable Style/Next
-      end
-
-      conf
-    end
-
-    def replace_slave_keys(conf)
-      conf.to_a.each do |env_name, env_config|
-        next unless env_name.end_with?("_slave")
-
-        replica_key = env_name.sub(/_slave$/, "_replica")
-        next if conf.key?(replica_key)
-
-        conf[replica_key] = env_config.deep_dup
       end
 
       conf
@@ -56,16 +35,14 @@ module ActiveRecordShards
 
     def expand_child!(parent, child)
       parent.each do |key, value|
-        unless ['slave', 'replica', 'shards'].include?(key) || value.is_a?(Hash)
+        unless ['replica', 'shards'].include?(key) || value.is_a?(Hash)
           child[key] ||= value
         end
       end
     end
 
     def configurations_with_shard_explosion=(conf)
-      exploded_configuration = explode(conf)
-      configuration_with_slave_keys_replaced = replace_slave_keys(exploded_configuration)
-      self.configurations_without_shard_explosion = configuration_with_slave_keys_replaced
+      self.configurations_without_shard_explosion = explode(conf)
     end
 
     def self.extended(base)

data/lib/active_record_shards/connection_switcher-6-1.rb

@@ -0,0 +1,31 @@
+module ActiveRecordShards
+  module ConnectionSwitcher
+    def connection_specification_name
+      name = current_shard_selection.resolve_connection_name(sharded: is_sharded?, configurations: configurations)
+
+      @_ars_connection_specification_names ||= {}
+      unless @_ars_connection_specification_names.include?(name)
+        unless configurations.configs_for(env_name: name, include_replicas: true).any? || name == "ActiveRecord::Base"
+          raise ActiveRecord::AdapterNotSpecified, "No database defined by #{name} in your database config. (configurations: #{configurations.configurations.map(&:env_name).inspect})"
+        end
+
+        @_ars_connection_specification_names[name] = true
+      end
+
+      name
+    end
+
+    private
+
+    def ensure_shard_connection
+      # See if we've connected before. If not, call `#establish_connection`
+      # so that ActiveRecord can resolve connection_specification_name to an
+      # ARS connection.
+      spec_name = connection_specification_name
+
+      pool = connection_handler.retrieve_connection_pool(spec_name)
+
+      connection_handler.establish_connection(spec_name.to_sym) if pool.nil?
+    end
+  end
+end

data/lib/active_record_shards/{connection_switcher-5-0.rb → connection_switcher-7-0.rb}

@@ -3,8 +3,13 @@ module ActiveRecordShards
     def connection_specification_name
       name = current_shard_selection.resolve_connection_name(sharded: is_sharded?, configurations: configurations)
 
-      unless configurations[name] || name == "primary"
-        raise ActiveRecord::AdapterNotSpecified, "No database defined by #{name} in your database config. (configurations: #{configurations.to_h.keys.inspect})"
+      @_ars_connection_specification_names ||= {}
+      unless @_ars_connection_specification_names.include?(name)
+        unless configurations.configs_for(env_name: name, include_hidden: true).any? || name == "ActiveRecord::Base"
+          raise ActiveRecord::AdapterNotSpecified, "No database defined by #{name} in your database config. (configurations: #{configurations.configurations.map(&:env_name).inspect})"
+        end
+
+        @_ars_connection_specification_names[name] = true
       end
 
       name
@@ -19,11 +24,8 @@ module ActiveRecordShards
       spec_name = connection_specification_name
 
       pool = connection_handler.retrieve_connection_pool(spec_name)
-      if pool.nil?
-        resolver = ActiveRecord::ConnectionAdapters::ConnectionSpecification::Resolver.new(configurations)
-        spec = resolver.spec(spec_name.to_sym, spec_name)
-        connection_handler.establish_connection(spec)
-      end
+
+      connection_handler.establish_connection(spec_name.to_sym) if pool.nil?
     end
   end
 end

data/lib/active_record_shards/connection_switcher.rb

@@ -4,26 +4,23 @@ require 'active_record_shards/shard_support'
 
 module ActiveRecordShards
   module ConnectionSwitcher
-    SHARD_NAMES_CONFIG_KEY = 'shard_names'
+    class LegacyConnectionHandlingError < StandardError; end
+
+    case "#{ActiveRecord::VERSION::MAJOR}.#{ActiveRecord::VERSION::MINOR}"
+    when '6.1', '7.0'
+      SHARD_NAMES_CONFIG_KEY = :shard_names
+    else
+      SHARD_NAMES_CONFIG_KEY = 'shard_names'
+    end
 
     def self.extended(base)
-      if ActiveRecord::VERSION::MAJOR >= 5
-        base.singleton_class.send(:alias_method, :load_schema_without_default_shard!, :load_schema!)
-        base.singleton_class.send(:alias_method, :load_schema!, :load_schema_with_default_shard!)
-      else
-        base.singleton_class.send(:alias_method, :columns_without_default_shard, :columns)
-        base.singleton_class.send(:alias_method, :columns, :columns_with_default_shard)
-      end
+      base.singleton_class.send(:alias_method, :load_schema_without_default_shard!, :load_schema!)
+      base.singleton_class.send(:alias_method, :load_schema!, :load_schema_with_default_shard!)
 
       base.singleton_class.send(:alias_method, :table_exists_without_default_shard?, :table_exists?)
       base.singleton_class.send(:alias_method, :table_exists?, :table_exists_with_default_shard?)
     end
 
-    def default_shard=(new_default_shard)
-      ActiveRecordShards::ShardSelection.default_shard = new_default_shard
-      switch_connection(shard: new_default_shard)
-    end
-
     def on_primary_db(&block)
       on_shard(nil, &block)
     end
@@ -62,22 +59,18 @@ module ActiveRecordShards
     def on_replica_if(condition, &block)
       condition ? on_replica(&block) : yield
     end
-    alias_method :on_slave_if, :on_replica_if
 
     def on_replica_unless(condition, &block)
       on_replica_if(!condition, &block)
     end
-    alias_method :on_slave_unless, :on_replica_unless
 
     def on_primary_if(condition, &block)
       condition ? on_primary(&block) : yield
     end
-    alias_method :on_master_if, :on_primary_if
 
     def on_primary_unless(condition, &block)
       on_primary_if(!condition, &block)
     end
-    alias_method :on_master_unless, :on_primary_unless
 
     def on_primary_or_replica(which, &block)
       if block_given?
@@ -86,7 +79,6 @@ module ActiveRecordShards
         PrimaryReplicaProxy.new(self, which)
       end
     end
-    alias_method :on_master_or_slave, :on_primary_or_replica
 
     # Executes queries using the replica database. Fails over to primary if no replica is found.
     # if you want to execute a block of code on the replica you can go:
@@ -100,25 +92,15 @@ module ActiveRecordShards
     def on_replica(&block)
       on_primary_or_replica(:replica, &block)
     end
-    alias_method :on_slave, :on_replica
 
     def on_primary(&block)
       on_primary_or_replica(:primary, &block)
     end
-    alias_method :on_master, :on_primary
-
-    # just to ease the transition from replica to active_record_shards
-    alias_method :with_slave, :on_replica
-    alias_method :with_slave_if, :on_replica_if
-    alias_method :with_slave_unless, :on_replica_unless
 
     def on_cx_switch_block(which, force: false, construct_ro_scope: nil, &block)
-      @disallow_replica ||= 0
-      @disallow_replica += 1 if [:primary, :master].include?(which)
-
-      ActiveRecordShards::Deprecation.warn('the `:master` option should be replaced with `:primary`!') if which == :master
+      self.disallow_replica += 1 if which == :primary
 
-      switch_to_replica = force || @disallow_replica.zero?
+      switch_to_replica = force || disallow_replica.zero?
       old_options = current_shard_selection.options
 
       switch_connection(replica: switch_to_replica)
@@ -131,10 +113,18 @@ module ActiveRecordShards
         readonly.scoping(&block)
       end
     ensure
-      @disallow_replica -= 1 if [:primary, :master].include?(which)
+      self.disallow_replica -= 1 if which == :primary
       switch_connection(old_options) if old_options
     end
 
+    def disallow_replica=(value)
+      Thread.current[:__active_record_shards__disallow_replica_by_thread] = value
+    end
+
+    def disallow_replica
+      Thread.current[:__active_record_shards__disallow_replica_by_thread] ||= 0
+    end
+
     def supports_sharding?
       shard_names.any?
     end
@@ -142,7 +132,6 @@ module ActiveRecordShards
     def on_replica?
       current_shard_selection.on_replica?
     end
-    alias_method :on_slave?, :on_replica?
 
     def current_shard_selection
       Thread.current[:shard_selection] ||= ShardSelection.new
@@ -165,7 +154,15 @@ module ActiveRecordShards
     def config_for_env
       @_ars_config_for_env ||= {}
       @_ars_config_for_env[shard_env] ||= begin
-        unless config = configurations[shard_env]
+        case "#{ActiveRecord::VERSION::MAJOR}.#{ActiveRecord::VERSION::MINOR}"
+        when '7.0'
+          config = configurations.configs_for(env_name: shard_env, include_hidden: true).first.configuration_hash
+        when '6.1'
+          config = configurations.configs_for(env_name: shard_env, include_replicas: true).first.configuration_hash
+        else
+          config = configurations[shard_env]
+        end
+        unless config
           raise "Did not find #{shard_env} in configurations, did you forget to add it to your database config? (configurations: #{configurations.to_h.keys.inspect})"
         end
 
@@ -175,6 +172,8 @@ module ActiveRecordShards
     alias_method :check_config_for_env, :config_for_env
 
     def switch_connection(options)
+      ensure_legacy_connection_handling if ActiveRecord.version >= Gem::Version.new('6.1')
+
       if options.any?
         if options.key?(:replica)
           current_shard_selection.on_replica = options[:replica]
@@ -190,6 +189,22 @@ module ActiveRecordShards
       end
     end
 
+    def ensure_legacy_connection_handling
+      unless legacy_connection_handling_owner.legacy_connection_handling
+        raise LegacyConnectionHandlingError, "ActiveRecordShards is _only_ compatible with ActiveRecord `legacy_connection_handling` set to `true`."
+      end
+    end
+
+    def legacy_connection_handling_owner
+      @legacy_connection_handling_owner ||=
+        case "#{ActiveRecord::VERSION::MAJOR}.#{ActiveRecord::VERSION::MINOR}"
+        when '7.0'
+          ActiveRecord
+        when '6.1'
+          ActiveRecord::Base
+        end
+    end
+
     def shard_env
       ActiveRecordShards.app_env
     end
@@ -204,14 +219,8 @@ module ActiveRecordShards
       end
     end
 
-    if ActiveRecord::VERSION::MAJOR >= 5
-      def load_schema_with_default_shard!
-        with_default_shard { load_schema_without_default_shard! }
-      end
-    else
-      def columns_with_default_shard
-        with_default_shard { columns_without_default_shard }
-      end
+    def load_schema_with_default_shard!
+      with_default_shard { load_schema_without_default_shard! }
     end
 
     def table_exists_with_default_shard?
@@ -227,21 +236,20 @@ module ActiveRecordShards
       def method_missing(method, *args, &block) # rubocop:disable Style/MethodMissingSuper, Style/MissingRespondToMissing
         @target.on_primary_or_replica(@which) { @target.send(method, *args, &block) }
       end
+      ruby2_keywords(:method_missing) if respond_to?(:ruby2_keywords, true)
     end
-
-    MasterSlaveProxy = PrimaryReplicaProxy
   end
 end
 
 case "#{ActiveRecord::VERSION::MAJOR}.#{ActiveRecord::VERSION::MINOR}"
-when '4.2'
-  require 'active_record_shards/connection_switcher-4-2'
-when '5.0'
-  require 'active_record_shards/connection_switcher-5-0'
 when '5.1', '5.2'
   require 'active_record_shards/connection_switcher-5-1'
 when '6.0'
   require 'active_record_shards/connection_switcher-6-0'
+when '6.1'
+  require 'active_record_shards/connection_switcher-6-1'
+when '7.0'
+  require 'active_record_shards/connection_switcher-7-0'
 else
   raise "ActiveRecordShards is not compatible with #{ActiveRecord::VERSION::STRING}"
 end

data/lib/active_record_shards/default_replica_patches.rb

@@ -22,21 +22,13 @@ module ActiveRecordShards
               #{method}_without_default_replica#{punctuation}(*args, &block)
             end
           end
-
+          ruby2_keywords(:#{method}_with_default_replica#{punctuation}) if respond_to?(:ruby2_keywords, true)
           alias_method :#{method}_without_default_replica#{punctuation}, :#{method}#{punctuation}
           alias_method :#{method}#{punctuation}, :#{method}_with_default_replica#{punctuation}
         #{class_method ? 'end' : ''}
       RUBY
     end
 
-    def self.wrap_method_in_on_slave(*args)
-      ActiveRecordShards::Deprecation.deprecation_warning(
-        :'self.wrap_method_in_on_slave',
-        :'self.wrap_method_in_on_replica'
-      )
-      wrap_method_in_on_replica(*args)
-    end
-
     def transaction_with_replica_off(*args, &block)
       if on_replica_by_default?
         begin
@@ -50,14 +42,9 @@ module ActiveRecordShards
         transaction_without_replica_off(*args, &block)
       end
     end
-    alias_method :transaction_with_slave_off, :transaction_with_replica_off
+    ruby2_keywords(:transaction_with_replica_off) if respond_to?(:ruby2_keywords, true)
 
     module InstanceMethods
-      # fix ActiveRecord to do the right thing, and use our aliased quote_value
-      def quote_value(*args, &block)
-        self.class.quote_value(*args, &block)
-      end
-
       def on_replica_unless_tx
         self.class.on_replica_unless_tx { yield }
       end
@@ -84,19 +71,11 @@ module ActiveRecordShards
       :table_exists?
     ].freeze
 
-    CLASS_SLAVE_METHODS = CLASS_REPLICA_METHODS
-    CLASS_FORCE_SLAVE_METHODS = CLASS_FORCE_REPLICA_METHODS
-
     def self.extended(base)
       CLASS_REPLICA_METHODS.each { |m| ActiveRecordShards::DefaultReplicaPatches.wrap_method_in_on_replica(true, base, m) }
       CLASS_FORCE_REPLICA_METHODS.each { |m| ActiveRecordShards::DefaultReplicaPatches.wrap_method_in_on_replica(true, base, m, force_on_replica: true) }
 
-      if ActiveRecord::VERSION::MAJOR >= 5
-        ActiveRecordShards::DefaultReplicaPatches.wrap_method_in_on_replica(true, base, :load_schema!, force_on_replica: true)
-      else
-        ActiveRecordShards::DefaultReplicaPatches.wrap_method_in_on_replica(true, base, :columns, force_on_replica: true)
-      end
-
+      ActiveRecordShards::DefaultReplicaPatches.wrap_method_in_on_replica(true, base, :load_schema!, force_on_replica: true)
       ActiveRecordShards::DefaultReplicaPatches.wrap_method_in_on_replica(false, base, :reload)
 
       base.class_eval do
@@ -119,7 +98,6 @@ module ActiveRecordShards
         yield
       end
     end
-    alias_method :on_slave_unless_tx, :on_replica_unless_tx
 
     def force_on_replica(&block)
       return yield if Thread.current[:_active_record_shards_in_migration]
@@ -133,11 +111,6 @@ module ActiveRecordShards
           ActiveRecordShards::DefaultReplicaPatches.wrap_method_in_on_replica(false, base, m)
         end
 
-        if ActiveRecord::VERSION::MAJOR == 4
-          # `where` and `having` clauses call `create_binds`, which will use the primary connection
-          ActiveRecordShards::DefaultReplicaPatches.wrap_method_in_on_replica(false, base, :create_binds, force_on_replica: true)
-        end
-
         ActiveRecordShards::DefaultReplicaPatches.wrap_method_in_on_replica(false, base, :to_sql, force_on_replica: true)
       end
 
@@ -210,20 +183,6 @@ module ActiveRecordShards
       end
     end
 
-    module AssociationsAssociationGetRecordsPatch
-      def get_records # rubocop:disable Naming/AccessorMethodName
-        if klass
-          on_replica_unless_tx { super }
-        else
-          super
-        end
-      end
-
-      def on_replica_unless_tx
-        klass.on_replica_unless_tx { yield }
-      end
-    end
-
     module AssociationsPreloaderAssociationAssociatedRecordsByOwnerPatch
       def associated_records_by_owner(preloader)
         if klass

data/lib/active_record_shards/default_shard.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module ActiveRecordShards
+  module DefaultShard
+    def default_shard=(new_default_shard)
+      if ars_shard_type?(new_default_shard)
+        ActiveRecordShards::ShardSelection.ars_default_shard = new_default_shard
+        switch_connection(shard: new_default_shard)
+      else
+        super
+      end
+    end
+
+    private
+
+    def ars_shard_type?(shard)
+      return true if ActiveRecord.version < Gem::Version.new('6.1')
+      return true if shard.nil?
+      return true if shard == :_no_shard
+      return true if shard.is_a?(Integer)
+
+      false
+    end
+  end
+end
+
+ActiveRecord::Base.singleton_class.prepend(ActiveRecordShards::DefaultShard)

data/lib/active_record_shards/migration.rb

@@ -19,11 +19,10 @@ module ActiveRecord
       # 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
+        ActiveRecord::InternalMetadata.create_table
       end
     end
+    ruby2_keywords(:initialize_with_sharding) if respond_to?(:ruby2_keywords, true)
     alias_method :initialize_without_sharding, :initialize
     alias_method :initialize, :initialize_with_sharding
 

data/lib/active_record_shards/model.rb

@@ -34,7 +34,6 @@ module ActiveRecordShards
         end
       end
     end
-    alias_method :on_slave_by_default?, :on_replica_by_default?
 
     def on_replica_by_default=(value)
       if self == ActiveRecord::Base
@@ -43,19 +42,16 @@ module ActiveRecordShards
         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_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_replica?
         @from_replica
       end
-      alias_method :from_slave?, :from_replica?
 
       def from_shard
         @from_shard

data/lib/active_record_shards/shard_selection.rb

@@ -3,71 +3,54 @@
 module ActiveRecordShards
   class ShardSelection
     NO_SHARD = :_no_shard
-    cattr_accessor :default_shard
+    cattr_accessor :ars_default_shard
 
     def initialize
       @on_replica = false
       @shard = nil
     end
 
-    if ActiveRecord::VERSION::MAJOR < 5
-
-      def shard(klass = nil)
-        if (@shard || self.class.default_shard) && (klass.nil? || klass.is_sharded?)
-          if @shard == NO_SHARD
-            nil
-          else
-            @shard || self.class.default_shard
-          end
-        end
-      end
-
-      def shard_name(klass = nil, try_replica = true)
-        the_shard = shard(klass)
-
-        @shard_names ||= {}
-        @shard_names[ActiveRecordShards.app_env] ||= {}
-        @shard_names[ActiveRecordShards.app_env][the_shard] ||= {}
-        @shard_names[ActiveRecordShards.app_env][the_shard][try_replica] ||= {}
-        @shard_names[ActiveRecordShards.app_env][the_shard][try_replica][@on_replica] ||= begin
-          s = ActiveRecordShards.app_env.dup
-          s << "_shard_#{the_shard}" if the_shard
-          s << "_replica"            if @on_replica && try_replica
-          s
-        end
+    def shard
+      if @shard.nil? || @shard == NO_SHARD
+        nil
+      else
+        @shard || self.class.ars_default_shard
       end
-
+    end
+    case "#{ActiveRecord::VERSION::MAJOR}.#{ActiveRecord::VERSION::MINOR}"
+    when '6.1', '7.0'
+      PRIMARY = "ActiveRecord::Base"
     else
-
-      def shard
-        if @shard.nil? || @shard == NO_SHARD
-          nil
-        else
-          @shard || self.class.default_shard
-        end
-      end
-
       PRIMARY = "primary"
-      def resolve_connection_name(sharded:, configurations:)
-        resolved_shard = sharded ? shard : nil
-        env = ActiveRecordShards.app_env
+    end
+    def resolve_connection_name(sharded:, configurations:)
+      resolved_shard = sharded ? shard : nil
+      env = ActiveRecordShards.app_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"
+      @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
+        replica_config = begin
+          case "#{ActiveRecord::VERSION::MAJOR}.#{ActiveRecord::VERSION::MINOR}"
+          when '7.0'
+            configurations.configs_for(env_name: "#{name}_replica", include_hidden: true).any?
+          when '6.1'
+            configurations.configs_for(env_name: "#{name}_replica", include_replicas: true).any?
           else
-            # ActiveRecord always names its default connection pool 'primary'
-            # while everything else is named by the configuration name
-            resolved_shard ? name : PRIMARY
+            configurations["#{name}_replica"]
           end
         end
+        if @on_replica && replica_config
+          "#{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
       end
-
     end
 
     def shard=(new_shard)
@@ -77,12 +60,10 @@ module ActiveRecordShards
     def on_replica?
       @on_replica
     end
-    alias_method :on_slave?, :on_replica?
 
     def on_replica=(new_replica)
       @on_replica = (new_replica == true)
     end
-    alias_method :on_slave=, :on_replica=
 
     def options
       { shard: @shard, replica: @on_replica }

data/lib/active_record_shards/shard_support.rb

@@ -23,15 +23,14 @@ module ActiveRecordShards
 
       exception = nil
       enum.each do
-        begin
-          record = @scope.find(*find_args)
-          return record if record
-        rescue ActiveRecord::RecordNotFound => e
-          exception = e
-        end
+        record = @scope.find(*find_args)
+        return record if record
+      rescue ActiveRecord::RecordNotFound => e
+        exception = e
       end
       raise exception
     end
+    ruby2_keywords(:find) if respond_to?(:ruby2_keywords, true)
 
     def count
       enum.inject(0) { |accum, _shard| @scope.clone.count + accum }

data/lib/active_record_shards/tasks.rb

@@ -9,10 +9,24 @@ end
 namespace :db do
   desc 'Drops the database for the current RAILS_ENV including shards'
   task drop: :load_config do
-    ActiveRecord::Base.configurations.to_h.each do |key, conf|
-      next if !key.start_with?(ActiveRecordShards.app_env) || key.end_with?("_replica", "_slave")
+    configurations = begin
+      case "#{ActiveRecord::VERSION::MAJOR}.#{ActiveRecord::VERSION::MINOR}"
+      when '6.1', '7.0'
+        ActiveRecord::Base.configurations.configurations.map { |configuration| [configuration.env_name, configuration.configuration_hash] }
+      else
+        ActiveRecord::Base.configurations.to_h
+      end
+    end
+
+    configurations.each do |key, conf|
+      next if !key.start_with?(ActiveRecordShards.app_env) || key.end_with?("_replica")
 
       begin
+        case "#{ActiveRecord::VERSION::MAJOR}.#{ActiveRecord::VERSION::MINOR}"
+        when '6.1', '7.0'
+          conf = conf.stringify_keys
+        end
+
         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"
@@ -30,13 +44,26 @@ 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.to_h.each do |key, conf|
-      next if !key.start_with?(ActiveRecordShards.app_env) || key.end_with?("_replica", "_slave")
+    configurations = begin
+      case "#{ActiveRecord::VERSION::MAJOR}.#{ActiveRecord::VERSION::MINOR}"
+      when '6.1', '7.0'
+        ActiveRecord::Base.configurations.configurations.map { |configuration| [configuration.env_name, configuration.configuration_hash] }
+      else
+        ActiveRecord::Base.configurations.to_h
+      end
+    end
+    configurations.each do |key, conf|
+      next if !key.start_with?(ActiveRecordShards.app_env) || key.end_with?("_replica")
 
       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
+        case "#{ActiveRecord::VERSION::MAJOR}.#{ActiveRecord::VERSION::MINOR}"
+        when '6.1', '7.0'
+          conf = conf.stringify_keys
+        end
+
         symbolized_configuration[:charset] = symbolized_configuration[:encoding]
 
         ActiveRecordShards::Tasks.root_connection(conf).create_database(conf['database'], symbolized_configuration)
@@ -78,14 +105,12 @@ namespace :db do
   namespace :test do
     desc 'Purges the test databases by dropping and creating'
     task purge: :load_config do |t|
-      begin
-        saved_env = Rails.env
-        Rails.env = 'test'
-        Rake.application.lookup('db:drop', t.scope).execute
-        Rake.application.lookup('db:create', t.scope).execute
-      ensure
-        Rails.env = saved_env
-      end
+      saved_env = Rails.env
+      Rails.env = 'test'
+      Rake.application.lookup('db:drop', t.scope).execute
+      Rake.application.lookup('db:create', t.scope).execute
+    ensure
+      Rails.env = saved_env
     end
   end
 end
@@ -96,15 +121,26 @@ module ActiveRecordShards
       def root_connection(conf)
         conf = conf.merge('database' => nil)
         spec = spec_for(conf)
-
-        ActiveRecord::Base.send("#{conf['adapter']}_connection", spec.config)
+        case "#{ActiveRecord::VERSION::MAJOR}.#{ActiveRecord::VERSION::MINOR}"
+        when '6.1', '7.0'
+          ActiveRecord::Base.send("#{conf['adapter']}_connection", spec.db_config.configuration_hash)
+        else
+          ActiveRecord::Base.send("#{conf['adapter']}_connection", spec.config)
+        end
       end
 
       private
 
       def spec_for(conf)
-        resolver = ActiveRecord::ConnectionAdapters::ConnectionSpecification::Resolver.new(ActiveRecord::Base.configurations)
-        resolver.spec(conf)
+        case "#{ActiveRecord::VERSION::MAJOR}.#{ActiveRecord::VERSION::MINOR}"
+        when '7.0'
+          ActiveRecord::Base.connection_handler.send(:resolve_pool_config, conf, ActiveRecord::Base, ActiveRecord::Base.current_role, ActiveRecord::Base.current_shard)
+        when '6.1'
+          ActiveRecord::Base.connection_handler.send(:resolve_pool_config, conf, ActiveRecord::Base)
+        else
+          resolver = ActiveRecord::ConnectionAdapters::ConnectionSpecification::Resolver.new(ActiveRecord::Base.configurations)
+          resolver.spec(conf)
+        end
       end
     end
   end

data/lib/active_record_shards.rb

@@ -9,6 +9,7 @@ require 'active_record_shards/connection_switcher'
 require 'active_record_shards/association_collection_connection_selection'
 require 'active_record_shards/migration'
 require 'active_record_shards/default_replica_patches'
+require 'active_record_shards/default_shard'
 require 'active_record_shards/schema_dumper_extension'
 
 module ActiveRecordShards
@@ -36,32 +37,6 @@ ActiveRecord::Associations::Builder::HasAndBelongsToMany.include(ActiveRecordSha
 ActiveRecord::SchemaDumper.prepend(ActiveRecordShards::SchemaDumperExtension)
 
 case "#{ActiveRecord::VERSION::MAJOR}.#{ActiveRecord::VERSION::MINOR}"
-when '4.2'
-  require 'active_record_shards/patches-4-2'
-
-  # 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)
@@ -87,7 +62,7 @@ when '5.2'
 
   # 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'
+when '6.0', '6.1', '7.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)
 
@@ -103,45 +78,3 @@ when '6.0'
 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=
-)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: active_record_shards
 version: !ruby/object:Gem::Version
-  version: 3.21.0
+  version: 5.3.1
 platform: ruby
 authors:
 - Benjamin Quorning
@@ -10,10 +10,10 @@ authors:
 - Mick Staugaard
 - Eric Chapweske
 - Ben Osheroff
-autorequire:
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-07-05 00:00:00.000000000 Z
+date: 2023-02-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -21,40 +21,40 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '4.2'
+        version: '5.1'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '6.1'
+        version: '7.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '4.2'
+        version: '5.1'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '6.1'
+        version: '7.1'
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '4.2'
+        version: '5.1'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '6.1'
+        version: '7.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '4.2'
+        version: '5.1'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '6.1'
+        version: '7.1'
 - !ruby/object:Gem::Dependency
   name: bump
   requirement: !ruby/object:Gem::Requirement
@@ -97,20 +97,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: mocha
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 1.4.0
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 1.4.0
 - !ruby/object:Gem::Dependency
   name: mysql2
   requirement: !ruby/object:Gem::Requirement
@@ -195,20 +181,15 @@ files:
 - lib/active_record_shards.rb
 - lib/active_record_shards/association_collection_connection_selection.rb
 - lib/active_record_shards/configuration_parser.rb
-- lib/active_record_shards/connection_handler.rb
-- lib/active_record_shards/connection_pool.rb
-- lib/active_record_shards/connection_specification.rb
-- lib/active_record_shards/connection_switcher-4-2.rb
-- lib/active_record_shards/connection_switcher-5-0.rb
 - lib/active_record_shards/connection_switcher-5-1.rb
 - lib/active_record_shards/connection_switcher-6-0.rb
+- lib/active_record_shards/connection_switcher-6-1.rb
+- lib/active_record_shards/connection_switcher-7-0.rb
 - lib/active_record_shards/connection_switcher.rb
 - lib/active_record_shards/default_replica_patches.rb
-- lib/active_record_shards/default_slave_patches.rb
-- lib/active_record_shards/deprecation.rb
+- lib/active_record_shards/default_shard.rb
 - lib/active_record_shards/migration.rb
 - lib/active_record_shards/model.rb
-- lib/active_record_shards/patches-4-2.rb
 - lib/active_record_shards/schema_dumper_extension.rb
 - lib/active_record_shards/shard_selection.rb
 - lib/active_record_shards/shard_support.rb
@@ -218,7 +199,7 @@ homepage: https://github.com/zendesk/active_record_shards
 licenses:
 - MIT
 metadata: {}
-post_install_message:
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -226,15 +207,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.3'
+      version: '2.6'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.6
-signing_key:
+rubygems_version: 3.0.3.1
+signing_key: 
 specification_version: 4
 summary: Simple database switching for ActiveRecord.
 test_files: []

data/lib/active_record_shards/connection_handler.rb

@@ -1,8 +0,0 @@
-# frozen_string_literal: true
-
-ActiveRecord::ConnectionAdapters::ConnectionHandler.class_eval do
-  remove_method :retrieve_connection_pool
-  def retrieve_connection_pool(klass)
-    class_to_pool[klass.connection_pool_name] ||= pool_for(klass)
-  end
-end

data/lib/active_record_shards/connection_pool.rb

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveRecordShards
-  ConnectionPoolNameDecorator = Struct.new(:name)
-
-  # It overrides given connection handler methods (they differ depend on
-  # Rails version).
-  #
-  # It takes the first argument, ActiveRecord::Base object or
-  # String (connection_pool_name), converts it in Struct object and
-  # passes to the original method.
-  #
-  # Example:
-  #   methods_to_override = [:establish_connection, :remove_connection]
-  #   ActiveRecordShards.override_connection_handler_methods(methods_to_override)
-  #
-  def self.override_connection_handler_methods(method_names)
-    method_names.each do |method_name|
-      ActiveRecord::ConnectionAdapters::ConnectionHandler.class_eval do
-        define_method("#{method_name}_with_connection_pool_name") do |*args|
-          unless args[0].is_a? ConnectionPoolNameDecorator
-            name = if args[0].is_a? String
-                     args[0]
-                   else
-                     args[0].connection_pool_name
-                   end
-            args[0] = ConnectionPoolNameDecorator.new(name)
-          end
-          send("#{method_name}_without_connection_pool_name", *args)
-        end
-        alias_method :"#{method_name}_without_connection_pool_name", method_name
-        alias_method method_name, :"#{method_name}_with_connection_pool_name"
-      end
-    end
-  end
-end

data/lib/active_record_shards/connection_specification.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-class << ActiveRecord::Base
-  remove_method :establish_connection if ActiveRecord::VERSION::MAJOR >= 5
-  def establish_connection(spec = ENV["DATABASE_URL"])
-    spec ||= ActiveRecord::ConnectionHandling::DEFAULT_ENV.call
-    spec = spec.to_sym if spec.is_a?(String)
-    resolver = ActiveRecordShards::ConnectionSpecification::Resolver.new configurations
-    spec = resolver.spec(spec)
-
-    unless respond_to?(spec.adapter_method)
-      raise AdapterNotFound, "database configuration specifies nonexistent #{spec.config[:adapter]} adapter"
-    end
-
-    remove_connection
-    specification_cache[connection_pool_name] = spec
-    connection_handler.establish_connection self, spec
-  end
-end

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

@@ -1,56 +0,0 @@
-module ActiveRecordShards
-  module ConnectionSwitcher
-    # Name of the connection pool. Used by ConnectionHandler to retrieve the current connection pool.
-    def connection_pool_name # :nodoc:
-      name = current_shard_selection.shard_name(self)
-
-      # e.g. if "production_replica" is not defined in `Configuration`, fall back to "production"
-      if configurations[name].nil? && on_replica?
-        current_shard_selection.shard_name(self, false)
-      else
-        name
-      end
-    end
-
-    private
-
-    def ensure_shard_connection
-      establish_shard_connection unless connected_to_shard?
-    end
-
-    def establish_shard_connection
-      name = connection_pool_name
-      spec = configurations[name]
-
-      if spec.nil?
-        raise ActiveRecord::AdapterNotSpecified, "No database defined by #{name} in your database config. (configurations: #{configurations.keys.inspect})"
-      end
-
-      specification_cache[name] ||= begin
-        resolver = ActiveRecordShards::ConnectionSpecification::Resolver.new configurations
-        resolver.spec(spec)
-      end
-
-      connection_handler.establish_connection(self, specification_cache[name])
-    end
-
-    def specification_cache
-      @@specification_cache ||= {}
-    end
-
-    # Helper method to clear global state when testing.
-    def clear_specification_cache
-      @@specification_cache = {}
-    end
-
-    def connection_pool_key
-      specification_cache[connection_pool_name]
-    end
-
-    def connected_to_shard?
-      specs_to_pools = Hash[connection_handler.connection_pool_list.map { |pool| [pool.spec, pool] }]
-
-      specs_to_pools.key?(connection_pool_key)
-    end
-  end
-end

data/lib/active_record_shards/default_slave_patches.rb

@@ -1,5 +0,0 @@
-ActiveRecordShards::Deprecation.warn('`DefaultSlavePatches` is deprecated, please use `DefaultReplicaPatches`.')
-
-module ActiveRecordShards
-  DefaultSlavePatches = DefaultReplicaPatches
-end

data/lib/active_record_shards/deprecation.rb

@@ -1,12 +0,0 @@
-module ActiveRecordShards
-  class Deprecation < ActiveSupport::Deprecation
-    # This allows us to define separate deprecation behavior for ActiveRecordShards, but defaults to
-    # the same behavior globally configured with ActiveSupport.
-    #
-    # For example, this allows us to silence our own deprecation warnings in test while still being
-    # able to fail tests for upstream deprecation warnings.
-    def behavior
-      @behavior ||= ActiveSupport::Deprecation.behavior
-    end
-  end
-end

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

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-require 'active_record_shards/connection_pool'
-require 'active_record_shards/connection_handler'
-require 'active_record_shards/connection_specification'
-
-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)