switchman 2.0.11 → 3.0.4

data/lib/switchman/active_record/reflection.rb

@@ -5,7 +5,7 @@ module Switchman
     module Reflection
       module AbstractReflection
         def shard(owner)
-          if polymorphic? || klass.shard_category == owner.class.shard_category
+          if polymorphic? || klass.connection_classes == owner.class.connection_classes
             # polymorphic associations assume the same shard as the owning item
             owner.shard
           else
@@ -28,21 +28,17 @@ module Switchman
         # this technically belongs on AssociationReflection, but we put it on
         # ThroughReflection as well, instead of delegating to its internal
         # HasManyAssociation, losing its proper `klass`
-        def association_scope_cache(conn, owner, &block)
-          key = conn.prepared_statements
-          if polymorphic?
-            key = [key, owner._read_attribute(@foreign_type)]
-          end
+        def association_scope_cache(klass, owner, &block)
+          key = self
+          key = [key, owner._read_attribute(@foreign_type)] if polymorphic?
           key = [key, shard(owner).id].flatten
-          @association_scope_cache[key] ||= @scope_lock.synchronize {
-            @association_scope_cache[key] ||= (::Rails.version >= "5.2" ? ::ActiveRecord::StatementCache.create(conn, &block) : block.call)
-          }
+          klass.cached_find_by_statement(key, &block)
         end
       end
 
       module AssociationReflection
         def join_id_for(owner)
-          owner.send(::Rails.version >= "5.2" ? join_foreign_key : active_record_primary_key) # use sharded id values in association binds
+          owner.send(join_foreign_key) # use sharded id values in association binds
         end
       end
     end

data/lib/switchman/active_record/relation.rb

@@ -4,53 +4,54 @@ module Switchman
   module ActiveRecord
     module Relation
       def self.prepended(klass)
-        klass::SINGLE_VALUE_METHODS.concat [ :shard, :shard_source ]
+        klass::SINGLE_VALUE_METHODS.concat %i[shard shard_source]
       end
 
       def initialize(*, **)
         super
-        self.shard_value = Shard.current(klass ? klass.shard_category : :primary) unless shard_value
+        self.shard_value = Shard.current(klass ? klass.connection_classes : :primary) unless shard_value
         self.shard_source_value = :implicit unless shard_source_value
       end
 
       def clone
         result = super
-        result.shard_value = Shard.current(klass ? klass.shard_category : :primary) unless shard_value
+        result.shard_value = Shard.current(klass ? klass.connection_classes : :primary) unless shard_value
         result
       end
 
       def merge(*)
         relation = super
-        if relation.shard_value != self.shard_value && relation.shard_source_value == :implicit
-          relation.shard_value = self.shard_value
-          relation.shard_source_value = self.shard_source_value
+        if relation.shard_value != shard_value && relation.shard_source_value == :implicit
+          relation.shard_value = shard_value
+          relation.shard_source_value = shard_source_value
         end
         relation
       end
 
       def new(*, &block)
-        primary_shard.activate(klass.shard_category) { super }
+        primary_shard.activate(klass.connection_classes) { super }
       end
 
       def create(*, &block)
-        primary_shard.activate(klass.shard_category) { super }
+        primary_shard.activate(klass.connection_classes) { super }
       end
 
       def create!(*, &block)
-        primary_shard.activate(klass.shard_category) { super }
+        primary_shard.activate(klass.connection_classes) { super }
       end
 
       def to_sql
-        primary_shard.activate(klass.shard_category) { super }
+        primary_shard.activate(klass.connection_classes) { super }
       end
 
       def explain
-        self.activate { |relation| relation.call_super(:explain, Relation) }
+        activate { |relation| relation.call_super(:explain, Relation) }
       end
 
       def records
         return @records if loaded?
-        results = self.activate { |relation| relation.call_super(:records, Relation) }
+
+        results = activate { |relation| relation.call_super(:records, Relation) }
         case shard_value
         when Array, ::ActiveRecord::Relation, ::ActiveRecord::Base
           @records = results
@@ -59,10 +60,10 @@ module Switchman
         results
       end
 
-      %I{update_all delete_all}.each do |method|
+      %I[update_all delete_all].each do |method|
         class_eval <<-RUBY, __FILE__, __LINE__ + 1
           def #{method}(*args)
-            result = self.activate { |relation| relation.call_super(#{method.inspect}, Relation, *args) }
+            result = self.activate(unordered: true) { |relation| relation.call_super(#{method.inspect}, Relation, *args) }
             result = result.sum if result.is_a?(Array)
             result
           end
@@ -74,15 +75,20 @@ module Switchman
         loose_mode = options[:loose] && is_integer
         # loose_mode: if we don't care about getting exactly batch_size ids in between
         # don't get the max - just get the min and add batch_size so we get that many _at most_
-        values = loose_mode ? "MIN(id)" : "MIN(id), MAX(id)"
+        values = loose_mode ? 'MIN(id)' : 'MIN(id), MAX(id)'
 
         batch_size = options[:batch_size].try(:to_i) || 1000
         quoted_primary_key = "#{klass.connection.quote_local_table_name(table_name)}.#{klass.connection.quote_column_name(primary_key)}"
-        as_id = " AS id" unless primary_key == 'id'
+        as_id = ' AS id' unless primary_key == 'id'
         subquery_scope = except(:select).select("#{quoted_primary_key}#{as_id}").reorder(primary_key.to_sym).limit(loose_mode ? 1 : batch_size)
         subquery_scope = subquery_scope.where("#{quoted_primary_key} <= ?", options[:end_at]) if options[:end_at]
 
-        first_subquery_scope = options[:start_at] ? subquery_scope.where("#{quoted_primary_key} >= ?", options[:start_at]) : subquery_scope
+        first_subquery_scope = if options[:start_at]
+                                 subquery_scope.where("#{quoted_primary_key} >= ?",
+                                                      options[:start_at])
+                               else
+                                 subquery_scope
+                               end
 
         ids = connection.select_rows("SELECT #{values} FROM (#{first_subquery_scope.to_sql}) AS subquery").first
 
@@ -97,28 +103,28 @@ module Switchman
         end
       end
 
-      def activate(&block)
+      def activate(unordered: false, &block)
         shards = all_shards
-        if (Array === shards && shards.length == 1)
-          if shards.first == DefaultShard || shards.first == Shard.current(klass.shard_category)
+        if Array === shards && shards.length == 1
+          if shards.first == DefaultShard || shards.first == Shard.current(klass.connection_classes)
             yield(self, shards.first)
           else
-            shards.first.activate(klass.shard_category) { yield(self, shards.first) }
+            shards.first.activate(klass.connection_classes) { yield(self, shards.first) }
           end
         else
           result_count = 0
           can_order = false
-          result = Shard.with_each_shard(shards, [klass.shard_category]) do
+          result = Shard.with_each_shard(shards, [klass.connection_classes]) do
             # don't even query other shards if we're already past the limit
             next if limit_value && result_count >= limit_value && order_values.empty?
 
-            relation = shard(Shard.current(klass.shard_category), :to_a)
+            relation = shard(Shard.current(klass.connection_classes), :to_a)
             # do a minimal query if possible
             relation = relation.limit(limit_value - result_count) if limit_value && !result_count.zero? && order_values.empty?
 
             shard_results = relation.activate(&block)
 
-            if shard_results.present?
+            if shard_results.present? && !unordered
               can_order ||= can_order_cross_shard_results? unless order_values.empty?
               raise OrderOnMultiShardQuery if !can_order && !order_values.empty? && result_count.positive?
 
@@ -142,12 +148,11 @@ module Switchman
         results.sort! do |l, r|
           result = 0
           order_values.each do |ov|
-            if l.respond_to?(ov.expr.name)
-              a = l.send(ov.expr.name)
-              b = r.send(ov.expr.name)
+            if l.is_a?(::ActiveRecord::Base)
+              a = l.attribute(ov.expr.name)
+              b = r.attribute(ov.expr.name)
             else
-              a = l.attributes[ov.expr.name]
-              b = r.attributes[ov.expr.name]
+              a, b = l, r
             end
             next if a == b
 

data/lib/switchman/active_record/spawn_methods.rb

@@ -3,27 +3,27 @@
 module Switchman
   module ActiveRecord
     module SpawnMethods
-      def shard_values_for_merge(r)
-        if shard_value != r.shard_value
-          if r.shard_source_value == :implicit
+      def shard_values_for_merge(rhs)
+        if shard_value != rhs.shard_value
+          if rhs.shard_source_value == :implicit
             final_shard_value = shard_value
             final_primary_shard = primary_shard
             final_shard_source_value = shard_source_value
           elsif shard_source_value == :implicit
-            final_shard_value = r.shard_value
-            final_primary_shard = r.primary_shard
-            final_shard_source_value = r.shard_source_value
+            final_shard_value = rhs.shard_value
+            final_primary_shard = rhs.primary_shard
+            final_shard_source_value = rhs.shard_source_value
           else
-            final_shard_source_value = [:explicit, :association].detect do |source_value|
-              shard_source_value == source_value || r.shard_source_value == source_value
+            final_shard_source_value = %i[explicit association].detect do |source_value|
+              shard_source_value == source_value || rhs.shard_source_value == source_value
             end
-            raise "unknown shard_source_value" unless final_shard_source_value
+            raise 'unknown shard_source_value' unless final_shard_source_value
 
             # have to merge shard_value
             lhs_shard_value = all_shards
-            rhs_shard_value = r.all_shards
-            if (::ActiveRecord::Relation === lhs_shard_value &&
-                ::ActiveRecord::Relation === rhs_shard_value)
+            rhs_shard_value = rhs.all_shards
+            if ::ActiveRecord::Relation === lhs_shard_value &&
+               ::ActiveRecord::Relation === rhs_shard_value
               final_shard_value = lhs_shard_value.merge(rhs_shard_value)
               final_primary_shard = Shard.default
             else
@@ -32,27 +32,25 @@ module Switchman
               final_shard_value = final_shard_value.first if final_shard_value.length == 1
             end
           end
-        elsif shard_source_value != r.shard_source_value
-          final_shard_source_value = [:explicit, :association, :implicit].detect do |source_value|
-            shard_source_value == source_value || r.shard_source_value == source_value
+        elsif shard_source_value != rhs.shard_source_value
+          final_shard_source_value = %i[explicit association implicit].detect do |source_value|
+            shard_source_value == source_value || rhs.shard_source_value == source_value
           end
-          raise "unknown shard_source_value" unless final_shard_source_value
-        else
-          # nothing fancy
+          raise 'unknown shard_source_value' unless final_shard_source_value
         end
 
         [final_shard_value, final_primary_shard, final_shard_source_value]
       end
 
-      def merge!(r)
-        return super unless ::ActiveRecord::Relation === r
+      def merge!(rhs)
+        return super unless ::ActiveRecord::Relation === rhs
 
         # have to figure out shard stuff *before* conditions are merged
-        final_shard_value, final_primary_shard, final_shard_source_value = shard_values_for_merge(r)
+        final_shard_value, final_primary_shard, final_shard_source_value = shard_values_for_merge(rhs)
 
         return super unless final_shard_source_value
 
-        if !final_shard_value
+        unless final_shard_value
           super
           self.shard_source_value = final_shard_source_value
           return self
@@ -61,16 +59,16 @@ module Switchman
         return none! if final_shard_value == []
 
         # change the primary shard if necessary before merging
-        if primary_shard != final_primary_shard && r.primary_shard != final_primary_shard
+        if primary_shard != final_primary_shard && rhs.primary_shard != final_primary_shard
           shard!(final_primary_shard)
-          r = r.shard(final_primary_shard)
-          super(r)
+          rhs = rhs.shard(final_primary_shard)
+          super(rhs)
         elsif primary_shard != final_primary_shard
           shard!(final_primary_shard)
-          super(r)
-        elsif r.primary_shard != final_primary_shard
-          r = r.shard(final_primary_shard)
-          super(r)
+          super(rhs)
+        elsif rhs.primary_shard != final_primary_shard
+          rhs = rhs.shard(final_primary_shard)
+          super(rhs)
         else
           super
         end

data/lib/switchman/active_record/statement_cache.rb

@@ -7,18 +7,13 @@ module Switchman
         def create(connection, &block)
           relation = block.call ::ActiveRecord::StatementCache::Params.new
 
-          if ::Rails.version >= "5.2"
-            query_builder, binds = connection.cacheable_query(self, relation.arel)
-            bind_map = ::ActiveRecord::StatementCache::BindMap.new(binds)
-            new(relation.arel, bind_map, relation.klass)
-          else
-            bind_map = ::ActiveRecord::StatementCache::BindMap.new(relation.bound_attributes)
-            new relation.arel, bind_map
-          end
+          _query_builder, binds = connection.cacheable_query(self, relation.arel)
+          bind_map = ::ActiveRecord::StatementCache::BindMap.new(binds)
+          new(relation.arel, bind_map, relation.klass)
         end
       end
 
-      def initialize(arel, bind_map, klass=nil)
+      def initialize(arel, bind_map, klass = nil)
         @arel = arel
         @bind_map = bind_map
         @klass = klass
@@ -31,49 +26,39 @@ module Switchman
       # (e.g. infer from the primary key or use the current shard)
 
       def execute(*args)
-        if ::Rails.version >= '5.2'
-          params, connection = args
-          klass = @klass
-        else
-          params, klass, connection = args
-        end
+        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.shard_category)
+        current_shard = Shard.current(klass.connection_classes)
         target_shard ||= current_shard
 
         bind_values = bind_map.bind(params, current_shard, target_shard)
 
-        target_shard.activate(klass.shard_category) do
+        target_shard.activate(klass.connection_classes) do
           sql = qualified_query_builder(target_shard, klass).sql_for(bind_values, connection)
           klass.find_by_sql(sql, bind_values)
         end
       end
 
-      if ::Rails.version < '5.2'
-        def qualified_query_builder(shard, klass)
-          @qualified_query_builders[shard.id] ||= klass.connection.cacheable_query(self.class, @arel)
-        end
-      else
-        def qualified_query_builder(shard, klass)
-          @qualified_query_builders[shard.id] ||= klass.connection.cacheable_query(self.class, @arel).first
-        end
+      def qualified_query_builder(shard, klass)
+        @qualified_query_builders[shard.id] ||= klass.connection.cacheable_query(self.class, @arel).first
       end
 
       module BindMap
         # performs id transposition here instead of query_methods.rb
         def bind(values, current_shard, target_shard)
           bas = @bound_attributes.dup
-          @indexes.each_with_index do |offset,i|
+          @indexes.each_with_index do |offset, i|
             ba = bas[offset]
-            if ba.is_a?(::ActiveRecord::Relation::QueryAttribute) && ba.value.sharded
-              new_value = Shard.relative_id_for(values[i], current_shard, target_shard || current_shard)
-            else
-              new_value = values[i]
-            end
+            new_value = if ba.is_a?(::ActiveRecord::Relation::QueryAttribute) && ba.value.sharded
+                          Shard.relative_id_for(values[i], current_shard, target_shard || current_shard)
+                        else
+                          values[i]
+                        end
             bas[offset] = ba.with_cast_value(new_value)
           end
           bas
@@ -83,9 +68,7 @@ module Switchman
           primary_ba_index = @bound_attributes.index do |ba|
             ba.is_a?(::ActiveRecord::Relation::QueryAttribute) && ba.value.primary
           end
-          if primary_ba_index
-            @indexes.index(primary_ba_index)
-          end
+          @indexes.index(primary_ba_index) if primary_ba_index
         end
       end
     end

data/lib/switchman/active_record/tasks/database_tasks.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Switchman
+  module ActiveRecord
+    module Tasks
+      module DatabaseTasks
+        def drop(*)
+          super
+          # no really, it's gone
+          Switchman.cache.delete('default_shard')
+          Shard.default(reload: true)
+        end
+      end
+    end
+  end
+end

data/lib/switchman/active_support/cache.rb

@@ -8,10 +8,8 @@ module Switchman
           store = super
           # can't use defined?, because it's a _ruby_ autoloaded constant,
           # so just checking that will cause it to get required
-          if store.class.name == "ActiveSupport::Cache::RedisCacheStore" && !::ActiveSupport::Cache::RedisCacheStore.ancestors.include?(RedisCacheStore)
-            ::ActiveSupport::Cache::RedisCacheStore.prepend(RedisCacheStore)
-          end
-          store.options[:namespace] ||= lambda { Shard.current.default? ? nil : "shard_#{Shard.current.id}" }
+          ::ActiveSupport::Cache::RedisCacheStore.prepend(RedisCacheStore) if store.instance_of?(ActiveSupport::Cache::RedisCacheStore) && !::ActiveSupport::Cache::RedisCacheStore.ancestors.include?(RedisCacheStore)
+          store.options[:namespace] ||= -> { Shard.current.default? ? nil : "shard_#{Shard.current.id}" }
           store
         end
       end
@@ -22,7 +20,7 @@ module Switchman
           # unfortunately, it uses the keys command, which is extraordinarily inefficient in a large redis instance
           # fortunately, we can assume we control the entire instance, because we set up the namespacing, so just
           # always unset it temporarily for clear calls
-          namespace = nil
+          namespace = nil # rubocop:disable Lint/ShadowedArgument
           super
         end
       end

data/lib/switchman/arel.rb

@@ -3,29 +3,34 @@
 module Switchman
   module Arel
     module Table
-      def model
-        type_caster.model
+      def klass
+        @klass || ::ActiveRecord::Base
       end
     end
+
     module Visitors
       module ToSql
-        def visit_Arel_Nodes_TableAlias *args
+        # rubocop:disable Naming/MethodName
+
+        def visit_Arel_Nodes_TableAlias(*args)
           o, collector = args
           collector = visit o.relation, collector
-          collector << " "
+          collector << ' '
           collector << quote_local_table_name(o.name)
         end
 
-        def visit_Arel_Attributes_Attribute *args
+        def visit_Arel_Attributes_Attribute(*args)
           o = args.first
           join_name = o.relation.table_alias || o.relation.name
           result = "#{quote_local_table_name join_name}.#{quote_column_name o.name}"
-          result = args.last << result
-          result
+          args.last << result
         end
 
-        def quote_local_table_name name
+        # rubocop:enable Naming/MethodName
+
+        def quote_local_table_name(name)
           return name if ::Arel::Nodes::SqlLiteral === name
+
           @connection.quote_local_table_name(name)
         end
       end