switchman 3.4.2 → 3.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 28d87755bf2331cbbf2931e7d35dddd688983c168c583b27dd60ae58d78072db
-  data.tar.gz: 500e141f914db02c5dd51cd9a595abc00306750a418641ceb09adb7cee207de7
+  metadata.gz: 1f6f878b1a2a9ba1dc0c75ce4fcd5d299178ea7940a048190bd4b181ae306339
+  data.tar.gz: 19b31ce1e456fbecf2a9ba9b15644bc6073cd521b6a604da81a0c5f8977f579a
 SHA512:
-  metadata.gz: 94c9b870a65599c0d5775d32cd9dd1bfc3235c541eeb07127e5e8e8c773447da3ba1e0460ce8a340709354aceede546b9d6ccf8dd0360bff7e494f267a6791e1
-  data.tar.gz: 6ea8348a8aaa9eb80ae763d2c8ccca23949e329f0f9ae2df7eef59344fdf3d4660b6e7419f479bc5d67be5e42fdd73f49abf7f0ceb853c0469c38b0899559424
+  metadata.gz: bad542adf6c09d1e1e50ef3054a8ca8d106bd3eedb7cb9dbbe544e44dd88c7f19226e7dd0d805ad5a5685009be7b9c9fe20623182c8c624c88724d00d7bc5656
+  data.tar.gz: 43b76369798a3683f838e392466cec0628d0c4a309354db7ccadcafca604f6eeffdcc460e036ca8d0f105c7abed2987baa23d51b830e628951c057adb554f305

data/Rakefile

@@ -2,37 +2,38 @@
 # frozen_string_literal: true
 
 begin
-  require 'bundler/setup'
+  require "bundler/setup"
 rescue LoadError
-  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+  puts "You must `gem install bundler` and `bundle install` to run rake tasks"
 end
 begin
-  require 'rdoc/task'
+  require "rdoc/task"
 rescue LoadError
-  require 'rdoc/rdoc'
-  require 'rake/rdoctask'
+  require "rdoc/rdoc"
+  require "rake/rdoctask"
   RDoc::Task = Rake::RDocTask
 end
 
 RDoc::Task.new(:rdoc) do |rdoc|
-  rdoc.rdoc_dir = 'rdoc'
-  rdoc.title    = 'Switchman'
-  rdoc.options << '--line-numbers'
-  rdoc.rdoc_files.include('lib/**/*.rb')
+  rdoc.rdoc_dir = "rdoc"
+  rdoc.title    = "Switchman"
+  rdoc.options << "--line-numbers"
+  rdoc.rdoc_files.include("lib/**/*.rb")
 end
 
-APP_RAKEFILE = File.expand_path('spec/dummy/Rakefile', __dir__)
-load 'rails/tasks/engine.rake'
+load "./spec/tasks/coverage.rake"
+APP_RAKEFILE = File.expand_path("spec/dummy/Rakefile", __dir__)
+load "rails/tasks/engine.rake"
 
 Bundler::GemHelper.install_tasks
 
-require 'rspec/core/rake_task'
+require "rspec/core/rake_task"
 RSpec::Core::RakeTask.new
 
-require 'rubocop/rake_task'
+require "rubocop/rake_task"
 
 RuboCop::RakeTask.new do |task|
-  task.options = ['-S']
+  task.options = ["-S"]
 end
 
 task default: %i[spec]

data/db/migrate/20180828183945_add_default_shard_index.rb

@@ -5,7 +5,7 @@ class AddDefaultShardIndex < ActiveRecord::Migration[4.2]
     Switchman::Shard.where(default: nil).update_all(default: false) if Switchman::Shard.current.default?
     change_column_default :switchman_shards, :default, false
     change_column_null :switchman_shards, :default, false
-    options = if connection.adapter_name == 'PostgreSQL'
+    options = if connection.adapter_name == "PostgreSQL"
                 { unique: true, where: '"default"' }
               else
                 {}

data/db/migrate/20190114212900_add_unique_name_indexes.rb

@@ -3,9 +3,15 @@
 class AddUniqueNameIndexes < ActiveRecord::Migration[4.2]
   def change
     add_index :switchman_shards, %i[database_server_id name], unique: true
-    add_index :switchman_shards, :database_server_id, unique: true, where: 'name IS NULL',
-                                                      name: 'index_switchman_shards_unique_primary_shard'
-    add_index :switchman_shards, '(true)', unique: true, where: 'database_server_id IS NULL AND name IS NULL',
-                                           name: 'index_switchman_shards_unique_primary_db_and_shard'
+    add_index :switchman_shards,
+              :database_server_id,
+              unique: true,
+              where: "name IS NULL",
+              name: "index_switchman_shards_unique_primary_shard"
+    add_index :switchman_shards,
+              "(true)",
+              unique: true,
+              where: "database_server_id IS NULL AND name IS NULL",
+              name: "index_switchman_shards_unique_primary_db_and_shard"
   end
 end

data/lib/switchman/active_record/associations.rb

@@ -24,10 +24,15 @@ module Switchman
 
       module CollectionAssociation
         def find_target
-          shards = reflection.options[:multishard] && owner.respond_to?(:associated_shards) ? owner.associated_shards : [shard]
+          shards = if reflection.options[:multishard] && owner.respond_to?(:associated_shards)
+                     owner.associated_shards
+                   else
+                     [shard]
+                   end
           # activate both the owner and the target's shard category, so that Reflection#join_id_for,
           # when called for the owner, will be returned relative to shard the query will execute on
-          Shard.with_each_shard(shards, [klass.connection_class_for_self, owner.class.connection_class_for_self].uniq) do
+          Shard.with_each_shard(shards,
+                                [klass.connection_class_for_self, owner.class.connection_class_for_self].uniq) do
             super
           end
         end
@@ -128,7 +133,12 @@ module Switchman
                 Shard.lookup(shard).activate do
                   scope_was = loader_query.scope
                   begin
-                    loader_query.instance_variable_set(:@scope, loader_query.scope.shard(Shard.current(loader_query.scope.model.connection_class_for_self)))
+                    loader_query.instance_variable_set(
+                      :@scope,
+                      loader_query.scope.shard(
+                        Shard.current(loader_query.scope.model.connection_class_for_self)
+                      )
+                    )
                     ret += loader_query.load_records_for_keys(keys) do |record|
                       loaders.each { |l| l.set_inverse(record) }
                     end
@@ -186,7 +196,7 @@ module Switchman
             # #compare_by_identity makes such owners different hash keys
             @records_by_owner = {}.compare_by_identity
 
-            if ::Rails.version >= '7.0'
+            if ::Rails.version >= "7.0"
               raw_records ||= loader_query.records_for([self])
             elsif owner_keys.empty?
               raw_records ||= []
@@ -210,7 +220,8 @@ module Switchman
                 relative_owner_keys = partitioned_owners.map do |owner|
                   key = owner[owner_key_name]
                   if key && owner.class.sharded_column?(owner_key_name)
-                    key = Shard.relative_id_for(key, owner.shard,
+                    key = Shard.relative_id_for(key,
+                                                owner.shard,
                                                 Shard.current(klass.connection_class_for_self))
                   end
                   convert_key(key)

data/lib/switchman/active_record/attribute_methods.rb

@@ -31,8 +31,16 @@ module Switchman
           # and not the silly one in AR::AttributeMethods::PrimaryKey
           return unless sharded_column?(@primary_key)
 
-          class_eval(build_sharded_getter('id', '_read_attribute(@primary_key)', "::#{connection_class_for_self.name}"), __FILE__, __LINE__)
-          class_eval(build_sharded_setter('id', @primary_key, "::#{connection_class_for_self.name}"), __FILE__, __LINE__)
+          class_eval(
+            build_sharded_getter("id",
+                                 "_read_attribute(@primary_key)",
+                                 "::#{connection_class_for_self.name}"),
+            __FILE__,
+            __LINE__
+          )
+          class_eval(build_sharded_setter("id", @primary_key, "::#{connection_class_for_self.name}"),
+                     __FILE__,
+                     __LINE__)
         end
 
         protected
@@ -47,7 +55,7 @@ module Switchman
         end
 
         def define_cached_method(owner, name, namespace:, as:, &block)
-          if ::Rails.version < '7.0'
+          if ::Rails.version < "7.0"
             yield owner
             owner.rename_method(as, name)
           else
@@ -57,7 +65,10 @@ module Switchman
 
         def define_method_global_attribute(attr_name, owner:)
           if sharded_column?(attr_name)
-            define_cached_method(owner, "global_#{attr_name}", as: "sharded_global_#{attr_name}", namespace: :switchman) do |batch|
+            define_cached_method(owner,
+                                 "global_#{attr_name}",
+                                 as: "sharded_global_#{attr_name}",
+                                 namespace: :switchman) do |batch|
               batch << <<-RUBY
                 def sharded_global_#{attr_name}
                   raw_value = original_#{attr_name}
@@ -69,13 +80,16 @@ module Switchman
               RUBY
             end
           else
-            define_method_unsharded_column(attr_name, 'global', owner)
+            define_method_unsharded_column(attr_name, "global", owner)
           end
         end
 
         def define_method_local_attribute(attr_name, owner:)
           if sharded_column?(attr_name)
-            define_cached_method(owner, "local_#{attr_name}", as: "sharded_local_#{attr_name}", namespace: :switchman) do |batch|
+            define_cached_method(owner,
+                                 "local_#{attr_name}",
+                                 as: "sharded_local_#{attr_name}",
+                                 namespace: :switchman) do |batch|
               batch << <<-RUBY
                 def sharded_local_#{attr_name}
                   raw_value = original_#{attr_name}
@@ -85,7 +99,7 @@ module Switchman
               RUBY
             end
           else
-            define_method_unsharded_column(attr_name, 'local', owner)
+            define_method_unsharded_column(attr_name, "local", owner)
           end
         end
 
@@ -97,7 +111,13 @@ module Switchman
             if reflection.options[:polymorphic]
               # a polymorphic association has to be discovered at runtime. This code ends up being something like
               # context_type.&.constantize&.connection_class_for_self
-              "begin;read_attribute(:#{reflection.foreign_type})&.constantize&.connection_class_for_self;rescue NameError;::ActiveRecord::Base;end"
+              <<~RUBY
+                begin
+                  read_attribute(:#{reflection.foreign_type})&.constantize&.connection_class_for_self
+                rescue NameError
+                  ::ActiveRecord::Base
+                end
+              RUBY
             else
               # otherwise we can just return a symbol for the statically known type of the association
               "::#{reflection.klass.connection_class_for_self.name}"
@@ -111,9 +131,14 @@ module Switchman
           if sharded_column?(attr_name)
             reflection = reflection_for_integer_attribute(attr_name)
             class_name = connection_class_for_self_code_for_reflection(reflection)
-            safe_class_name = class_name.unpack1('h*')
-            define_cached_method(owner, attr_name, as: "sharded_#{safe_class_name}_#{attr_name}", namespace: :switchman) do |batch|
-              batch << build_sharded_getter("sharded_#{safe_class_name}_#{attr_name}", "original_#{attr_name}", class_name)
+            safe_class_name = class_name.unpack1("h*")
+            define_cached_method(owner,
+                                 attr_name,
+                                 as: "sharded_#{safe_class_name}_#{attr_name}",
+                                 namespace: :switchman) do |batch|
+              batch << build_sharded_getter("sharded_#{safe_class_name}_#{attr_name}",
+                                            "original_#{attr_name}",
+                                            class_name)
             end
           else
             define_cached_method(owner, attr_name, as: "plain_#{attr_name}", namespace: :switchman) do |batch|
@@ -153,8 +178,11 @@ module Switchman
           if sharded_column?(attr_name)
             reflection = reflection_for_integer_attribute(attr_name)
             class_name = connection_class_for_self_code_for_reflection(reflection)
-            safe_class_name = class_name.unpack1('h*')
-            define_cached_method(owner, "#{attr_name}=", as: "sharded_#{safe_class_name}_#{attr_name}=", namespace: :switchman) do |batch|
+            safe_class_name = class_name.unpack1("h*")
+            define_cached_method(owner,
+                                 "#{attr_name}=",
+                                 as: "sharded_#{safe_class_name}_#{attr_name}=",
+                                 namespace: :switchman) do |batch|
               batch << build_sharded_setter("sharded_#{safe_class_name}_#{attr_name}", attr_name, class_name)
             end
           else
@@ -178,7 +206,10 @@ module Switchman
 
         def define_method_original_attribute(attr_name, owner:)
           if sharded_column?(attr_name)
-            define_cached_method(owner, "original_#{attr_name}", as: "sharded_original_#{attr_name}", namespace: :switchman) do |batch|
+            define_cached_method(owner,
+                                 "original_#{attr_name}",
+                                 as: "sharded_original_#{attr_name}",
+                                 namespace: :switchman) do |batch|
               batch << <<-RUBY
                 def sharded_original_#{attr_name}
                   _read_attribute("#{attr_name}") { |n| missing_attribute(n, caller) }
@@ -186,14 +217,17 @@ module Switchman
               RUBY
             end
           else
-            define_method_unsharded_column(attr_name, 'global', owner)
+            define_method_unsharded_column(attr_name, "global", owner)
           end
         end
 
         def define_method_original_attribute=(attr_name, owner:)
           return unless sharded_column?(attr_name)
 
-          define_cached_method(owner, "original_#{attr_name}=", as: "sharded_original_#{attr_name}=", namespace: :switchman) do |batch|
+          define_cached_method(owner,
+                               "original_#{attr_name}=",
+                               as: "sharded_original_#{attr_name}=",
+                               namespace: :switchman) do |batch|
             batch << <<-RUBY
               def sharded_original_#{attr_name}=(new_value)
                 _write_attribute('#{attr_name}', new_value)
@@ -203,9 +237,12 @@ module Switchman
         end
 
         def define_method_unsharded_column(attr_name, prefix, owner)
-          return if columns_hash["#{prefix}_#{attr_name}"] || attr_name == 'id'
+          return if columns_hash["#{prefix}_#{attr_name}"] || attr_name == "id"
 
-          define_cached_method(owner, "#{prefix}_#{attr_name}", as: "unsharded_#{prefix}_#{attr_name}", namespace: :switchman) do |batch|
+          define_cached_method(owner,
+                               "#{prefix}_#{attr_name}",
+                               as: "unsharded_#{prefix}_#{attr_name}",
+                               namespace: :switchman) do |batch|
             batch << <<-RUBY
               def unsharded_#{prefix}_#{attr_name}
                 raise NoMethodError, "undefined method `#{prefix}_#{attr_name}'; are you missing an association?"
@@ -217,8 +254,8 @@ module Switchman
 
       def self.prepended(klass)
         klass.singleton_class.prepend(ClassMethods)
-        klass.attribute_method_prefix 'global_', 'local_', 'original_'
-        klass.attribute_method_affix prefix: 'original_', suffix: '='
+        klass.attribute_method_prefix "global_", "local_", "original_"
+        klass.attribute_method_affix prefix: "original_", suffix: "="
       end
 
       # these are called if the specific methods haven't been defined yet
@@ -226,7 +263,11 @@ module Switchman
         return super unless self.class.sharded_column?(attr_name)
 
         reflection = self.class.send(:reflection_for_integer_attribute, attr_name)
-        ::Switchman::Shard.relative_id_for(super, shard, ::Switchman::Shard.current(connection_class_for_self_for_reflection(reflection)))
+        ::Switchman::Shard.relative_id_for(
+          super,
+          shard,
+          ::Switchman::Shard.current(connection_class_for_self_for_reflection(reflection))
+        )
       end
 
       def attribute=(attr_name, new_value)
@@ -236,7 +277,11 @@ module Switchman
         end
 
         reflection = self.class.send(:reflection_for_integer_attribute, attr_name)
-        super(::Switchman::Shard.relative_id_for(new_value, ::Switchman::Shard.current(connection_class_for_self_for_reflection(reflection)), shard))
+        super(::Switchman::Shard.relative_id_for(
+          new_value,
+          ::Switchman::Shard.current(connection_class_for_self_for_reflection(reflection)),
+          shard
+        ))
       end
 
       def global_attribute(attr_name)

data/lib/switchman/active_record/base.rb

@@ -67,7 +67,10 @@ module Switchman
         end
 
         def establish_connection(config_or_env = nil)
-          raise ArgumentError, 'establish connection cannot be used on the non-current shard/role' if config_or_env.is_a?(Symbol) && config_or_env != ::Rails.env.to_sym
+          if config_or_env.is_a?(Symbol) && config_or_env != ::Rails.env.to_sym
+            raise ArgumentError,
+                  "establish connection cannot be used on the non-current shard/role"
+          end
 
           # Ensure we don't randomly surprise change the connection parms associated with a shard/role
           config_or_env = nil if config_or_env == ::Rails.env.to_sym
@@ -82,9 +85,15 @@ module Switchman
         end
 
         def connected_to_stack
-          return super if ::Rails.version < '7.0' ? Thread.current.thread_variable?(:ar_connected_to_stack) : ::ActiveSupport::IsolatedExecutionState.key?(:active_record_connected_to_stack)
+          has_own_stack = if ::Rails.version < "7.0"
+                            Thread.current.thread_variable?(:ar_connected_to_stack)
+                          else
+                            ::ActiveSupport::IsolatedExecutionState.key?(:active_record_connected_to_stack)
+                          end
 
           ret = super
+          return ret if has_own_stack
+
           DatabaseServer.guard_servers
           ret
         end
@@ -96,10 +105,13 @@ module Switchman
           sharded_role = nil
           connected_to_stack.reverse_each do |hash|
             shard_role = hash.dig(:shard_roles, target_shard)
-            if shard_role && (hash[:klasses].include?(::ActiveRecord::Base) || hash[:klasses].include?(connection_class_for_self))
-              sharded_role = shard_role
-              break
+            unless shard_role &&
+                   (hash[:klasses].include?(::ActiveRecord::Base) || hash[:klasses].include?(connection_class_for_self))
+              next
             end
+
+            sharded_role = shard_role
+            break
           end
           # Allow a shard-specific role to be reverted to regular inheritance
           return sharded_role if sharded_role && sharded_role != :_switchman_inherit
@@ -119,13 +131,15 @@ module Switchman
 
         def current_switchman_shard
           connected_to_stack.reverse_each do |hash|
-            return hash[:switchman_shard] if hash[:switchman_shard] && hash[:klasses].include?(connection_class_for_self)
+            if hash[:switchman_shard] && hash[:klasses].include?(connection_class_for_self)
+              return hash[:switchman_shard]
+            end
           end
 
           Shard.default
         end
 
-        if ::Rails.version < '7.0'
+        if ::Rails.version < "7.0"
           def connection_class_for_self
             connection_classes
           end
@@ -172,13 +186,17 @@ module Switchman
       end
 
       def destroy_shadow_records(target_shards: [Shard.current])
-        raise Errors::ShadowRecordError, 'Cannot be called on a shadow record.' if shadow_record?
-        raise Errors::MethodUnsupportedForUnshardedTableError, 'Cannot be called on a record belonging to an unsharded table.' unless self.class.sharded_column?(self.class.primary_key)
+        raise Errors::ShadowRecordError, "Cannot be called on a shadow record." if shadow_record?
+
+        unless self.class.sharded_column?(self.class.primary_key)
+          raise Errors::MethodUnsupportedForUnshardedTableError,
+                "Cannot be called on a record belonging to an unsharded table."
+        end
 
         Array(target_shards).each do |target_shard|
           next if target_shard == shard
 
-          target_shard.activate { self.class.where('id = ?', global_id).delete_all }
+          target_shard.activate { self.class.where("id = ?", global_id).delete_all }
         end
       end
 
@@ -270,8 +288,10 @@ module Switchman
 
       def id_for_database
         if self.class.sharded_primary_key?
-          # It's an int, so so it's safe to just return it without passing it through anything else
-          # In theory we should do `@attributes[@primary_key].type.serialize(id)`, but that seems to have surprising side-effects
+          # It's an int, so it's safe to just return it without passing it
+          # through anything else. In theory we should do
+          # `@attributes[@primary_key].type.serialize(id)`, but that seems to
+          # have surprising side-effects
           id
         else
           super

data/lib/switchman/active_record/calculations.rb

@@ -28,7 +28,7 @@ module Switchman
 
       def execute_simple_calculation(operation, column_name, distinct)
         operation = operation.to_s.downcase
-        if operation == 'average'
+        if operation == "average"
           result = calculate_simple_average(column_name, distinct)
         else
           result = activate do |relation|
@@ -36,11 +36,11 @@ module Switchman
           end
           if result.is_a?(Array)
             case operation
-            when 'count', 'sum'
+            when "count", "sum"
               result = result.sum
-            when 'minimum'
+            when "minimum"
               result = result.min
-            when 'maximum'
+            when "maximum"
               result = result.max
             end
           end
@@ -52,20 +52,20 @@ module Switchman
         # See activerecord#execute_simple_calculation
         relation = except(:order)
         column = aggregate_column(column_name)
-        relation.select_values = [operation_over_aggregate_column(column, 'average', distinct).as('average'),
-                                  operation_over_aggregate_column(column, 'count', distinct).as('count')]
+        relation.select_values = [operation_over_aggregate_column(column, "average", distinct).as("average"),
+                                  operation_over_aggregate_column(column, "count", distinct).as("count")]
 
         initial_results = relation.activate { |rel| klass.connection.select_all(rel) }
         if initial_results.is_a?(Array)
           initial_results.each do |r|
-            r['average'] = type_cast_calculated_value_switchman(r['average'], column_name, 'average')
-            r['count'] = type_cast_calculated_value_switchman(r['count'], column_name, 'count')
+            r["average"] = type_cast_calculated_value_switchman(r["average"], column_name, "average")
+            r["count"] = type_cast_calculated_value_switchman(r["count"], column_name, "count")
           end
-          result = initial_results.map { |r| r['average'] * r['count'] }.sum / initial_results.map do |r|
-                                                                                 r['count']
-                                                                               end.sum
+          result = initial_results.sum { |r| r["average"] * r["count"] } / initial_results.sum do |r|
+                                                                             r["count"]
+                                                                           end
         else
-          result = type_cast_calculated_value_switchman(initial_results.first['average'], column_name, 'average')
+          result = type_cast_calculated_value_switchman(initial_results.first["average"], column_name, "average")
         end
         result
       end
@@ -90,7 +90,7 @@ module Switchman
             row[opts[:aggregate_alias]] = type_cast_calculated_value_switchman(
               row[opts[:aggregate_alias]], column_name, opts[:operation]
             )
-            row['count'] = row['count'].to_i if opts[:operation] == 'average'
+            row["count"] = row["count"].to_i if opts[:operation] == "average"
 
             opts[:group_columns].each do |aliaz, _type, group_column_name|
               if opts[:associated] && (aliaz == opts[:group_aliases].first)
@@ -109,7 +109,7 @@ module Switchman
       private
 
       def type_cast_calculated_value_switchman(value, column_name, operation)
-        if ::Rails.version < '7.0'
+        if ::Rails.version < "7.0"
           type_cast_calculated_value(value, operation) do |val|
             column = aggregate_column(column_name)
             type ||= column.try(:type_caster) ||
@@ -125,7 +125,7 @@ module Switchman
       end
 
       def column_name_for(field)
-        field.respond_to?(:name) ? field.name.to_s : field.to_s.split('.').last
+        field.respond_to?(:name) ? field.name.to_s : field.to_s.split(".").last
       end
 
       def grouped_calculation_options(operation, column_name, distinct)
@@ -135,7 +135,8 @@ module Switchman
         group_attrs = group_values
         if group_attrs.first.respond_to?(:to_sym)
           association  = klass.reflect_on_association(group_attrs.first.to_sym)
-          associated   = group_attrs.size == 1 && association && association.macro == :belongs_to # only count belongs_to associations
+          # only count belongs_to associations
+          associated   = group_attrs.size == 1 && association && association.macro == :belongs_to
           group_fields = Array(associated ? association.foreign_key : group_attrs)
         else
           group_fields = group_attrs
@@ -146,18 +147,20 @@ module Switchman
         group_columns = group_aliases.zip(group_fields).map do |aliaz, field|
           [aliaz, type_for(field), column_name_for(field)]
         end
-        opts.merge!(association: association, associated: associated,
-                    group_aliases: group_aliases, group_columns: group_columns,
+        opts.merge!(association: association,
+                    associated: associated,
+                    group_aliases: group_aliases,
+                    group_columns: group_columns,
                     group_fields: group_fields)
 
         opts
       end
 
       def aggregate_alias_for(operation, column_name)
-        if operation == 'count' && column_name == :all
-          'count_all'
-        elsif operation == 'average'
-          'average'
+        if operation == "count" && column_name == :all
+          "count_all"
+        elsif operation == "average"
+          "average"
         else
           column_alias_for("#{operation} #{column_name}")
         end
@@ -173,13 +176,14 @@ module Switchman
             opts[:distinct]
           ).as(opts[:aggregate_alias])
         ]
-        if opts[:operation] == 'average'
+        if opts[:operation] == "average"
           # include count in average so we can recalculate the average
           # across all shards if needed
           select_values << operation_over_aggregate_column(
             aggregate_column(opts[:column_name]),
-            'count', opts[:distinct]
-          ).as('count')
+            "count",
+            opts[:distinct]
+          ).as("count")
         end
 
         haves = having_clause.send(:predicates)
@@ -205,22 +209,22 @@ module Switchman
           key = key.first if key.size == 1
           value = row[opts[:aggregate_alias]]
 
-          if opts[:operation] == 'average'
+          if opts[:operation] == "average"
             if result.key?(key)
               old_value, old_count = result[key]
-              new_count = old_count + row['count']
-              new_value = ((old_value * old_count) + (value * row['count'])) / new_count
+              new_count = old_count + row["count"]
+              new_value = ((old_value * old_count) + (value * row["count"])) / new_count
               result[key] = [new_value, new_count]
             else
-              result[key] = [value, row['count']]
+              result[key] = [value, row["count"]]
             end
           elsif result.key?(key)
             case opts[:operation]
-            when 'count', 'sum'
+            when "count", "sum"
               result[key] += value
-            when 'minimum'
+            when "minimum"
               result[key] = value if value < result[key]
-            when 'maximum'
+            when "maximum"
               result[key] = value if value > result[key]
             end
           else
@@ -228,7 +232,7 @@ module Switchman
           end
         end
 
-        result.transform_values!(&:first) if opts[:operation] == 'average'
+        result.transform_values!(&:first) if opts[:operation] == "average"
 
         result
       end

data/lib/switchman/active_record/connection_pool.rb

@@ -48,7 +48,9 @@ module Switchman
       end
 
       def switch_database(conn)
-        @schemas = conn.current_schemas if !@schemas && conn.adapter_name == 'PostgreSQL' && !current_shard.database_server.config[:shard_name]
+        if !@schemas && conn.adapter_name == "PostgreSQL" && !current_shard.database_server.config[:shard_name]
+          @schemas = conn.current_schemas
+        end
 
         conn.shard = current_shard
       end
@@ -56,7 +58,7 @@ module Switchman
       private
 
       def current_shard
-        ::Rails.version < '7.0' ? connection_klass.current_switchman_shard : connection_class.current_switchman_shard
+        (::Rails.version < "7.0") ? connection_klass.current_switchman_shard : connection_class.current_switchman_shard
       end
 
       def tls_key