switchman 4.1.1 → 4.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 61591d46b119d4e93de2453131f6ec149238ece00df45ddabaac44a4fa67449c
-  data.tar.gz: b055255214698f518056b88b1ba311243412b8a7b6757b239c4eb1b6caab7bf8
+  metadata.gz: cfb4e89f881628a5d90c8f309ddf587fdc5bfebe5bc7985c79fea9dd06e7168c
+  data.tar.gz: baa3202cd9fb68347d71d43adecdbe3124fe3f4f604558f92546e8fa5c5b4773
 SHA512:
-  metadata.gz: a5c9b984bb1004b66269a070c39c20a8dab48b61f648716ec63e1144123cea232f42fdc670d923c85339e89ed6fca3bb93b28cf64560401b0b94ded01e0d96f9
-  data.tar.gz: 0ee98392b52fce11f7b6ec11badaea968a46b984f459e5ed00c047afa82adaf726b4a37f1e24c437a36713c849802bd3b37de6e3df7270aa31e272ee77ce2d39
+  metadata.gz: c351d3ff898e668ac7a8c8ab40e9cf2249f428a2d2bbc9a16573334e1599cb9bcac20a47a3534e70b7900fd76ca55f6f4a8625c9dc7c8bb3ef1b4ade95a17ff3
+  data.tar.gz: e3205573c3bbf8d8bf8a1e87beaaaed1adc2dba268f53ec1bac8c870f29f51ecdce923028eaa8528cffb9250965fc7b72d8d2dce4882c63edb0ad0d66d624a57

data/lib/switchman/active_record/abstract_adapter.rb

@@ -27,12 +27,6 @@ module Switchman
         quote_table_name(name)
       end
 
-      if ::Rails.version < "7.1"
-        def schema_migration
-          ::ActiveRecord::SchemaMigration
-        end
-      end
-
       protected
 
       def log(...)

data/lib/switchman/active_record/associations.rb

@@ -23,7 +23,7 @@ module Switchman
       end
 
       module CollectionAssociation
-        def find_target
+        def find_target(async: false)
           shards = if reflection.options[:multishard] && owner.respond_to?(:associated_shards)
                      owner.associated_shards
                    else
@@ -38,6 +38,8 @@ module Switchman
               # otherwise, the super call will set the shard_value to the object, causing it to iterate too many times
               # over the associated shards
               scope.shard(Shard.current(scope.klass.connection_class_for_self), :association).to_a
+            elsif ::Rails.version < "8.0"
+              super()
             else
               super
             end
@@ -251,78 +253,60 @@ module Switchman
           self.shard_source_value = :association
         end
 
-        def shard(*args)
-          scope.shard(*args)
+        def shard(*)
+          scope.shard(*)
         end
       end
 
       module AutosaveAssociation
-        if ::Rails.version < "7.1"
-          def association_foreign_key_changed?(reflection, record, key)
-            return false if reflection.through_reflection?
+        def association_foreign_key_changed?(reflection, record, key)
+          return false if reflection.through_reflection?
 
-            # have to use send instead of _read_attribute because sharding
-            record.has_attribute?(reflection.foreign_key) && record.send(reflection.foreign_key) != key
-          end
-
-          def save_belongs_to_association(reflection)
-            # this seems counter-intuitive, but the autosave code will assign to attribute bypassing switchman,
-            # after reading the id attribute _without_ bypassing switchman. So we need Shard.current for the
-            # category of the associated record to match Shard.current for the category of self
-            shard.activate(connection_class_for_self_for_reflection(reflection)) { super }
-          end
-        else
-          def association_foreign_key_changed?(reflection, record, key)
-            return false if reflection.through_reflection?
+          foreign_key = Array(reflection.foreign_key)
+          return false unless foreign_key.all? { |k| record._has_attribute?(k) }
 
-            foreign_key = Array(reflection.foreign_key)
-            return false unless foreign_key.all? { |k| record._has_attribute?(k) }
+          # have to use send instead of _read_attribute because sharding
+          foreign_key.map { |k| record.send(k) } != Array(key)
+        end
 
-            # have to use send instead of _read_attribute because sharding
-            foreign_key.map { |k| record.send(k) } != Array(key)
-          end
+        def save_belongs_to_association(reflection)
+          association = association_instance_get(reflection.name)
+          return unless association&.loaded? && !association.stale_target?
 
-          def save_belongs_to_association(reflection)
-            association = association_instance_get(reflection.name)
-            return unless association&.loaded? && !association.stale_target?
+          record = association.load_target
+          return unless record && !record.destroyed?
 
-            record = association.load_target
-            return unless record && !record.destroyed?
+          autosave = reflection.options[:autosave]
 
-            autosave = reflection.options[:autosave]
+          if autosave && record.marked_for_destruction?
+            foreign_key = Array(reflection.foreign_key)
+            foreign_key.each { |key| self[key] = nil }
+            record.destroy
+          elsif autosave != false
+            saved = record.save(validate: !autosave) if record.new_record? || (autosave && record.changed_for_autosave?)
 
-            if autosave && record.marked_for_destruction?
+            if association.updated?
+              primary_key = Array(compute_primary_key(reflection, record)).map(&:to_s)
               foreign_key = Array(reflection.foreign_key)
-              foreign_key.each { |key| self[key] = nil }
-              record.destroy
-            elsif autosave != false
-              if record.new_record? || (autosave && record.changed_for_autosave?)
-                saved = record.save(validate: !autosave)
-              end
 
-              if association.updated?
-                primary_key = Array(compute_primary_key(reflection, record)).map(&:to_s)
-                foreign_key = Array(reflection.foreign_key)
-
-                primary_key_foreign_key_pairs = primary_key.zip(foreign_key)
-                primary_key_foreign_key_pairs.each do |pk, fk|
-                  # Notable change: add relative_id_for here
-                  association_id = if record.class.sharded_column?(pk)
-                                     Shard.relative_id_for(
-                                       record._read_attribute(pk),
-                                       record.shard,
-                                       shard
-                                     )
-                                   else
-                                     record._read_attribute(pk)
-                                   end
-                  self[fk] = association_id unless self[fk] == association_id
-                end
-                association.loaded!
+              primary_key_foreign_key_pairs = primary_key.zip(foreign_key)
+              primary_key_foreign_key_pairs.each do |pk, fk|
+                # Notable change: add relative_id_for here
+                association_id = if record.class.sharded_column?(pk)
+                                   Shard.relative_id_for(
+                                     record._read_attribute(pk),
+                                     record.shard,
+                                     shard
+                                   )
+                                 else
+                                   record._read_attribute(pk)
+                                 end
+                self[fk] = association_id unless self[fk] == association_id
               end
-
-              saved if autosave
+              association.loaded!
             end
+
+            saved if autosave
           end
         end
       end

data/lib/switchman/active_record/attribute_methods.rb

@@ -55,13 +55,13 @@ module Switchman
           raise if connection.open_transactions.positive?
         end
 
-        def define_cached_method(owner, name, namespace:, as:, &block)
+        def define_cached_method(owner, name, namespace:, as:, &)
           if ::Rails.version < "7.1.4"
             # https://github.com/rails/rails/commit/a2a12fc2e3f4e6d06f81d4c74c88f8e6b3369ee6#diff-5b59ece6d9396b596f06271cec0ea726e3360911383511c49b1a66f454bfc2b6L30
             # These arguments were effectively swapped in Rails 7.1.4, so previous versions need them reversed
-            owner.define_cached_method(as, namespace:, as: name, &block)
+            owner.define_cached_method(as, namespace:, as: name, &)
           else
-            owner.define_cached_method(name, namespace:, as:, &block)
+            owner.define_cached_method(name, namespace:, as:, &)
           end
         end
 

data/lib/switchman/active_record/base.rb

@@ -53,11 +53,7 @@ module Switchman
         end
 
         def clear_query_caches_for_current_thread
-          pools = if ::Rails.version < "7.1"
-                    ::ActiveRecord::Base.connection_handler.connection_pool_list
-                  else
-                    ::ActiveRecord::Base.connection_handler.connection_pool_list(:all)
-                  end
+          pools = ::ActiveRecord::Base.connection_handler.connection_pool_list(:all)
           pools.each do |pool|
             if ::Rails.version < "7.2"
               pool.connection(switch_shard: false).clear_query_cache if pool.active_connection?
@@ -145,7 +141,7 @@ module Switchman
         klass.singleton_class.prepend(ClassMethods)
         klass.singleton_class.prepend(Switchman::ActiveRecord::Relation::InsertUpsertAll) if ::Rails.version < "7.2"
         klass.scope :non_shadow, lambda { |key = primary_key|
-                                   where(key => (QueryMethods::NonTransposingValue.new(0)..
+                                   where(key => (QueryMethods::NonTransposingValue.new(0)...
                                                  QueryMethods::NonTransposingValue.new(Shard::IDS_PER_SHARD)))
                                  }
         klass.scope :shadow, lambda { |key = primary_key|

data/lib/switchman/active_record/calculations.rb

@@ -95,7 +95,7 @@ module Switchman
             opts[:group_columns].each do |aliaz, _type, group_column_name|
               if opts[:associated] && (aliaz == opts[:group_aliases].first)
                 row[aliaz] = key_records[Shard.relative_id_for(row[aliaz], shard, target_shard)]
-              elsif group_column_name && @klass.sharded_column?(group_column_name)
+              elsif group_column_name && klass.sharded_column?(group_column_name)
                 row[aliaz] = Shard.relative_id_for(row[aliaz], shard, target_shard)
               end
             end
@@ -106,41 +106,39 @@ module Switchman
         compact_grouped_calculation_rows(rows, opts)
       end
 
-      if ::Rails.version >= "7.1"
-        def ids
-          return super unless klass.sharded_primary_key?
+      def ids
+        return super unless klass.sharded_primary_key?
 
-          if loaded?
-            result = records.map do |record|
-              Shard.relative_id_for(record._read_attribute(primary_key),
-                                    record.shard,
-                                    Shard.current(klass.connection_class_for_self))
-            end
-            return @async ? Promise::Complete.new(result) : result
+        if loaded?
+          result = records.map do |record|
+            Shard.relative_id_for(record._read_attribute(primary_key),
+                                  record.shard,
+                                  Shard.current(klass.connection_class_for_self))
           end
+          return @async ? Promise::Complete.new(result) : result
+        end
 
-          if has_include?(primary_key)
-            relation = apply_join_dependency.group(primary_key)
-            return relation.ids
-          end
+        if has_include?(primary_key)
+          relation = apply_join_dependency.group(primary_key)
+          return relation.ids
+        end
 
-          columns = arel_columns([primary_key])
-          base_shard = Shard.current(klass.connection_class_for_self)
-          activate do |r|
-            relation = r.spawn
-            relation.select_values = columns
-
-            result = if relation.where_clause.contradiction?
-                       ::ActiveRecord::Result.empty
-                     else
-                       skip_query_cache_if_necessary do
-                         klass.connection.select_all(relation, "#{klass.name} Ids", async: @async)
-                       end
+        columns = arel_columns([primary_key])
+        base_shard = Shard.current(klass.connection_class_for_self)
+        activate do |r|
+          relation = r.spawn
+          relation.select_values = columns
+
+          result = if relation.where_clause.contradiction?
+                     ::ActiveRecord::Result.empty
+                   else
+                     skip_query_cache_if_necessary do
+                       klass.connection.select_all(relation, "#{klass.name} Ids", async: @async)
                      end
+                   end
 
-            result.then do |res|
-              type_cast_pluck_values(res, columns).map { |id| Shard.relative_id_for(id, Shard.current, base_shard) }
-            end
+          result.then do |res|
+            type_cast_pluck_values(res, columns).map { |id| Shard.relative_id_for(id, Shard.current, base_shard) }
           end
         end
       end
@@ -161,10 +159,7 @@ module Switchman
       def grouped_calculation_options(operation, column_name, distinct)
         opts = { operation:, column_name:, distinct: }
 
-        # Rails 7.0.5
-        if defined?(::ActiveRecord::Calculations::ColumnAliasTracker)
-          column_alias_tracker = ::ActiveRecord::Calculations::ColumnAliasTracker.new(connection)
-        end
+        column_alias_tracker = ::ActiveRecord::Calculations::ColumnAliasTracker.new(connection)
 
         opts[:aggregate_alias] = aggregate_alias_for(operation, column_name, column_alias_tracker)
         group_attrs = group_values
@@ -179,11 +174,7 @@ module Switchman
 
         group_aliases = group_fields.map do |field|
           field = connection.visitor.compile(field) if ::Arel.arel_node?(field)
-          if column_alias_tracker
-            column_alias_tracker.alias_for(field.to_s.downcase)
-          else
-            column_alias_for(field.to_s.downcase)
-          end
+          column_alias_tracker.alias_for(field.to_s.downcase)
         end
         group_columns = group_aliases.zip(group_fields).map do |aliaz, field|
           [aliaz, type_for(field), column_name_for(field)]
@@ -202,10 +193,8 @@ module Switchman
           "count_all"
         elsif operation == "average"
           "average"
-        elsif column_alias_tracker
-          column_alias_tracker.alias_for("#{operation} #{column_name}")
         else
-          column_alias_for("#{operation} #{column_name}")
+          column_alias_tracker.alias_for("#{operation} #{column_name}")
         end
       end
 

data/lib/switchman/active_record/connection_pool.rb

@@ -3,25 +3,6 @@
 module Switchman
   module ActiveRecord
     module ConnectionPool
-      if ::Rails.version < "7.1"
-        def get_schema_cache(connection)
-          self.schema_cache ||= SharedSchemaCache.get_schema_cache(connection)
-          self.schema_cache.connection = connection
-
-          self.schema_cache
-        end
-
-        # rubocop:disable Naming/AccessorMethodName -- override method
-        def set_schema_cache(cache)
-          schema_cache = get_schema_cache(cache.connection)
-
-          cache.instance_variables.each do |x|
-            schema_cache.instance_variable_set(x, cache.instance_variable_get(x))
-          end
-        end
-        # rubocop:enable Naming/AccessorMethodName -- override method
-      end
-
       def default_schema
         connection_method = (::Rails.version < "7.2") ? :connection : :lease_connection
         send(connection_method) unless @schemas
@@ -89,7 +70,11 @@ module Switchman
       private
 
       def current_shard
-        connection_class.current_switchman_shard
+        if ::Rails.version < "8.0"
+          connection_class.current_switchman_shard
+        else
+          connection_descriptor.name.constantize.current_switchman_shard
+        end
       end
 
       def tls_key

data/lib/switchman/active_record/database_configurations.rb

@@ -7,26 +7,14 @@ module Switchman
       # since all should point to the same data, even if multiple are writable
       # (Picks 'primary' since it is guaranteed to exist and switchman handles activating
       # deploy through other means)
-      if ::Rails.version < "7.1"
-        def configs_for(include_replicas: false, name: nil, **)
-          res = super
-          if name && !include_replicas
-            return nil unless name.end_with?("primary")
-          elsif !include_replicas
-            return res.select { |config| config.name.end_with?("primary") }
-          end
-          res
-        end
-      else
-        def configs_for(include_hidden: false, name: nil, **)
-          res = super
-          if name && !include_hidden
-            return nil unless name.end_with?("primary")
-          elsif !include_hidden
-            return res.select { |config| config.name.end_with?("primary") }
-          end
-          res
+      def configs_for(include_hidden: false, name: nil, **)
+        res = super
+        if name && !include_hidden
+          return nil unless name.end_with?("primary")
+        elsif !include_hidden
+          return res.select { |config| config.name.end_with?("primary") }
         end
+        res
       end
 
       private

data/lib/switchman/active_record/finder_methods.rb

@@ -42,56 +42,32 @@ module Switchman
         primary_shard.activate { super }
       end
 
-      if ::Rails.version < "7.1"
-        def exists?(conditions = :none)
-          conditions = conditions.id if ::ActiveRecord::Base === conditions
-          return false unless conditions
-
-          relation = apply_join_dependency(eager_loading: false)
-          return false if ::ActiveRecord::NullRelation === relation
-
-          relation = relation.except(:select, :order).select("1 AS one").limit(1)
-
-          case conditions
-          when Array, Hash
-            relation = relation.where(conditions)
-          else
-            relation = relation.where(table[primary_key].eq(conditions)) if conditions != :none
-          end
-
-          relation.activate do |shard_rel|
-            return true if connection.select_value(shard_rel.arel, "#{name} Exists")
-          end
-          false
+      def exists?(conditions = :none)
+        return false if @none
+
+        if Base === conditions
+          raise ArgumentError, <<-TEXT.squish
+            You are passing an instance of ActiveRecord::Base to `exists?`.
+            Please pass the id of the object by calling `.id`.
+          TEXT
         end
-      else
-        def exists?(conditions = :none)
-          return false if @none
-
-          if Base === conditions
-            raise ArgumentError, <<-TEXT.squish
-              You are passing an instance of ActiveRecord::Base to `exists?`.
-              Please pass the id of the object by calling `.id`.
-            TEXT
-          end
 
-          return false if !conditions || limit_value == 0 # rubocop:disable Style/NumericPredicate
+        return false if !conditions || limit_value == 0 # rubocop:disable Style/NumericPredicate
 
-          if eager_loading?
-            relation = apply_join_dependency(eager_loading: false)
-            return relation.exists?(conditions)
-          end
+        if eager_loading?
+          relation = apply_join_dependency(eager_loading: false)
+          return relation.exists?(conditions)
+        end
 
-          relation = construct_relation_for_exists(conditions)
-          return false if relation.where_clause.contradiction?
+        relation = construct_relation_for_exists(conditions)
+        return false if relation.where_clause.contradiction?
 
-          relation.activate do |shard_rel|
-            return true if skip_query_cache_if_necessary do
-                             connection.select_rows(shard_rel.arel, "#{name} Exists?").size == 1
-                           end
+        relation.activate do |shard_rel|
+          return true if skip_query_cache_if_necessary do
+            connection.select_rows(shard_rel.arel, "#{name} Exists?").size == 1
           end
-          false
         end
+        false
       end
     end
   end

data/lib/switchman/active_record/log_subscriber.rb

@@ -5,11 +5,6 @@ module Switchman
     module LogSubscriber
       # sadly, have to completely replace this
       def sql(event)
-        if ::Rails.version < "7.1"
-          self.class.runtime += event.duration
-          return unless logger.debug?
-        end
-
         payload = event.payload
 
         return if ::ActiveRecord::LogSubscriber::IGNORE_PAYLOAD_NAMES.include?(payload[:name])
@@ -29,11 +24,7 @@ module Switchman
         end
 
         name = colorize_payload_name(name, payload[:name])
-        sql  = if ::Rails.version < "7.1"
-                 color(sql, sql_color(sql), true)
-               else
-                 color(sql, sql_color(sql), bold: true)
-               end
+        sql  = color(sql, sql_color(sql), bold: true)
 
         debug "  #{name}  #{sql}#{binds}#{shard}"
       end

data/lib/switchman/active_record/migration.rb

@@ -29,11 +29,7 @@ module Switchman
         db_name_hash = Zlib.crc32(Shard.current.name)
         shard_name_hash = ::ActiveRecord::Migrator::MIGRATOR_SALT * db_name_hash
         # Store in internalmetadata to allow other tools to be able to lock out migrations
-        if ::Rails.version < "7.1"
-          ::ActiveRecord::InternalMetadata[:migrator_advisory_lock_id] = shard_name_hash.to_s
-        else
-          @internal_metadata[:migrator_advisory_lock_id] = shard_name_hash.to_s
-        end
+        @internal_metadata[:migrator_advisory_lock_id] = shard_name_hash.to_s
         shard_name_hash
       end
 
@@ -51,26 +47,14 @@ module Switchman
 
     module MigrationContext
       def migrate(...)
-        connection = ::ActiveRecord::Base.connection
         schema_cache_holder = ::ActiveRecord::Base.connection_pool
-        schema_cache_holder = schema_cache_holder.schema_reflection if ::Rails.version >= "7.1"
-        previous_schema_cache = if ::Rails.version < "7.1"
-                                  schema_cache_holder.get_schema_cache(connection)
-                                else
-                                  schema_cache_holder.instance_variable_get(:@cache)
-                                end
-
-        if ::Rails.version < "7.1"
-          temporary_schema_cache = ::ActiveRecord::ConnectionAdapters::SchemaCache.new(connection)
+        schema_cache_holder = schema_cache_holder.schema_reflection
+        previous_schema_cache = schema_cache_holder.instance_variable_get(:@cache)
 
-          reset_column_information
-          schema_cache_holder.set_schema_cache(temporary_schema_cache)
-        else
-          schema_cache_holder.instance_variable_get(:@cache)
+        schema_cache_holder.instance_variable_get(:@cache)
 
-          reset_column_information
-          schema_cache_holder.clear!
-        end
+        reset_column_information
+        schema_cache_holder.clear!
 
         begin
           super

data/lib/switchman/active_record/query_cache.rb

@@ -5,67 +5,39 @@ module Switchman
     module QueryCache
       private
 
-      if ::Rails.version < "7.1"
-        def cache_sql(sql, name, binds)
-          # have to include the shard id in the cache key because of switching dbs on the same connection
-          sql = "#{shard.id}::#{sql}"
-          @lock.synchronize do
-            result =
-              if query_cache[sql].key?(binds)
-                args = {
-                  sql:,
-                  binds:,
-                  name:,
-                  connection_id: object_id,
-                  cached: true,
-                  type_casted_binds: -> { type_casted_binds(binds) }
-                }
-                ::ActiveSupport::Notifications.instrument(
-                  "sql.active_record",
-                  args
-                )
-                query_cache[sql][binds]
-              else
-                query_cache[sql][binds] = yield
-              end
-            result.dup
-          end
-        end
-      else
-        def cache_sql(sql, name, binds)
-          # have to include the shard id in the cache key because of switching dbs on the same connection
-          sql = "#{shard.id}::#{sql}"
-          key = binds.empty? ? sql : [sql, binds]
-          result = nil
-          hit = false
+      def cache_sql(sql, name, binds)
+        # have to include the shard id in the cache key because of switching dbs on the same connection
+        sql = "#{shard.id}::#{sql}"
+        key = binds.empty? ? sql : [sql, binds]
+        result = nil
+        hit = false
 
-          @lock.synchronize do
-            if ::Rails.version < "7.2"
-              if (result = @query_cache.delete(key))
-                hit = true
-                @query_cache[key] = result
-              else
-                result = @query_cache[key] = yield
-                @query_cache.shift if @query_cache_max_size && @query_cache.size > @query_cache_max_size
-              end
-            else
+        @lock.synchronize do
+          if ::Rails.version < "7.2"
+            if (result = @query_cache.delete(key))
               hit = true
-              result = @query_cache.compute_if_absent(key) do
-                hit = false
-                yield
-              end
+              @query_cache[key] = result
+            else
+              result = @query_cache[key] = yield
+              @query_cache.shift if @query_cache_max_size && @query_cache.size > @query_cache_max_size
+            end
+          else
+            hit = true
+            result = @query_cache.compute_if_absent(key) do
+              hit = false
+              yield
             end
           end
+        end
 
-          if hit
-            ::ActiveSupport::Notifications.instrument(
-              "sql.active_record",
-              cache_notification_info(sql, name, binds)
-            )
-          end
-
-          result.dup
+        if hit
+          ::ActiveSupport::Notifications.instrument(
+            "sql.active_record",
+            cache_notification_info(sql, name, binds)
+          )
         end
+
+        result.dup
       end
     end
   end

data/lib/switchman/active_record/statement_cache.rb

@@ -29,14 +29,14 @@ module Switchman
         params, connection = args
         klass = @klass
         target_shard = nil
-        if (primary_index = bind_map.primary_value_index)
+        if (primary_index = @bind_map.primary_value_index)
           primary_value = params[primary_index]
           target_shard = Shard.local_id_for(primary_value)[1]
         end
         current_shard = Shard.current(klass.connection_class_for_self)
         target_shard ||= current_shard
 
-        bind_values = bind_map.bind(params, current_shard, target_shard)
+        bind_values = @bind_map.bind(params, current_shard, target_shard)
 
         target_shard.activate(klass.connection_class_for_self) do
           sql = qualified_query_builder(target_shard, klass).sql_for(bind_values, connection)

data/lib/switchman/active_record/test_fixtures.rb

@@ -15,17 +15,13 @@ module Switchman
           # Code adapted from the code in rails proper
           @connection_subscriber =
             ::ActiveSupport::Notifications.subscribe("!connection.active_record") do |_, _, _, _, payload|
-              spec_name = if ::Rails.version < "7.1"
-                            payload[:spec_name] if payload.key?(:spec_name)
-                          elsif payload.key?(:connection_name)
-                            payload[:connection_name]
-                          end
+              spec_name = (payload[:connection_name] if payload.key?(:connection_name))
               shard = payload[:shard] if payload.key?(:shard)
 
               if spec_name && !FORBIDDEN_DB_ENVS.include?(shard)
                 begin
                   connection = ::ActiveRecord::Base.connection_handler.retrieve_connection(spec_name, shard: shard)
-                  connection.connect! if ::Rails.version >= "7.1" # eagerly validate the connection
+                  connection.connect! # eagerly validate the connection
                 rescue ::ActiveRecord::ConnectionNotEstablished
                   connection = nil
                 end

data/lib/switchman/arel.rb

@@ -38,31 +38,6 @@ module Switchman
           collector << quote_local_table_name(join_name) << "." << quote_column_name(o.name)
         end
 
-        if ::Rails.version < "7.1"
-          def visit_Arel_Nodes_HomogeneousIn(o, collector)
-            collector.preparable = false
-
-            collector << quote_local_table_name(o.table_name) << "." << quote_column_name(o.column_name)
-
-            collector << if o.type == :in
-                           " IN ("
-                         else
-                           " NOT IN ("
-                         end
-
-            values = o.casted_values
-
-            if values.empty?
-              collector << @connection.quote(nil)
-            else
-              collector.add_binds(values, o.proc_for_binds, &bind_block)
-            end
-
-            collector << ")"
-            collector
-          end
-        end
-
         # rubocop:enable Naming/MethodName
         # rubocop:enable Naming/MethodParameterName
 

data/lib/switchman/database_server.rb

@@ -259,11 +259,7 @@ module Switchman
           unless schema == false
             shard.activate do
               ::ActiveRecord::Base.connection.transaction(requires_new: true) do
-                if ::Rails.version < "7.1"
-                  ::ActiveRecord::Base.connection.migration_context.migrate
-                else
-                  ::ActiveRecord::MigrationContext.new(::ActiveRecord::Migrator.migrations_paths).migrate
-                end
+                ::ActiveRecord::MigrationContext.new(::ActiveRecord::Migrator.migrations_paths).migrate
               end
 
               ::ActiveRecord::Base.descendants.reject do |m|

data/lib/switchman/engine.rb

@@ -4,8 +4,6 @@ module Switchman
   class Engine < ::Rails::Engine
     isolate_namespace Switchman
 
-    # enable Rails 6.1 style connection handling
-    config.active_record.legacy_connection_handling = false if ::Rails.version < "7.1"
     config.active_record.writing_role = :primary
 
     ::GuardRail.singleton_class.prepend(GuardRail::ClassMethods)
@@ -47,9 +45,7 @@ module Switchman
           ActiveRecord::Associations::Preloader::Association::LoaderRecords
         )
         ::ActiveRecord::ConnectionAdapters::AbstractAdapter.prepend(ActiveRecord::AbstractAdapter)
-        unless ::Rails.version < "7.1"
-          ::ActiveRecord::ConnectionAdapters::ConnectionHandler.prepend(ActiveRecord::ConnectionHandler)
-        end
+        ::ActiveRecord::ConnectionAdapters::ConnectionHandler.prepend(ActiveRecord::ConnectionHandler)
         ::ActiveRecord::ConnectionAdapters::ConnectionPool.prepend(ActiveRecord::ConnectionPool)
         ::ActiveRecord::ConnectionAdapters::AbstractAdapter.prepend(ActiveRecord::QueryCache)
         ::ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.prepend(ActiveRecord::PostgreSQLAdapter)

data/lib/switchman/shard.rb

@@ -216,11 +216,7 @@ module Switchman
           # clear connections prior to forking (no more queries will be executed in the parent,
           # and we want them gone so that we don't accidentally use them post-fork doing something
           # silly like dealloc'ing prepared statements)
-          if ::Rails.version < "7.1"
-            ::ActiveRecord::Base.clear_all_connections!(nil)
-          else
-            ::ActiveRecord::Base.connection_handler.clear_all_connections!(:all)
-          end
+          ::ActiveRecord::Base.connection_handler.clear_all_connections!(:all)
 
           parent_process_name = sanitized_process_title
           ret = ::Parallel.map(scopes, in_processes: (scopes.length > 1) ? parallel : 0) do |server, subscope|

data/lib/switchman/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Switchman
-  VERSION = "4.1.1"
+  VERSION = "4.2.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: switchman
 version: !ruby/object:Gem::Version
-  version: 4.1.1
+  version: 4.2.0
 platform: ruby
 authors:
 - Cody Cutrer
@@ -10,7 +10,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-06-13 00:00:00.000000000 Z
+date: 2025-08-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -18,34 +18,34 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '7.0'
+        version: '7.1'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '7.3'
+        version: '8.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '7.0'
+        version: '7.1'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '7.3'
+        version: '8.1'
 - !ruby/object:Gem::Dependency
   name: guardrail
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 3.0.1
+        version: 3.1.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 3.0.1
+        version: 3.1.0
 - !ruby/object:Gem::Dependency
   name: parallel
   requirement: !ruby/object:Gem::Requirement
@@ -66,20 +66,20 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '7.0'
+        version: '7.1'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '7.3'
+        version: '8.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '7.0'
+        version: '7.1'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '7.3'
+        version: '8.1'
 - !ruby/object:Gem::Dependency
   name: debug
   requirement: !ruby/object:Gem::Requirement
@@ -312,14 +312,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '3.1'
+      version: '3.2'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.27
+rubygems_version: 3.4.19
 signing_key:
 specification_version: 4
 summary: Rails sharding magic