switchman 2.1.0 → 3.0.6

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,7 +60,7 @@ 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(unordered: true) { |relation| relation.call_super(#{method.inspect}, Relation, *args) }
@@ -74,21 +75,26 @@ 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
 
         while ids.first.present?
           ids.map!(&:to_i) if is_integer
-          ids << ids.first + batch_size if loose_mode
+          ids << (ids.first + batch_size) if loose_mode
 
           yield(*ids)
           last_value = ids.last
@@ -99,20 +105,20 @@ module Switchman
 
       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?
 
@@ -142,14 +148,11 @@ module Switchman
         results.sort! do |l, r|
           result = 0
           order_values.each do |ov|
-            if !l.is_a?(::ActiveRecord::Base)
-              a, b = l, r
-            elsif 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_record/test_fixtures.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Switchman
+  module ActiveRecord
+    module TestFixtures
+      FORBIDDEN_DB_ENVS = %i[development production].freeze
+      def setup_fixtures(config = ::ActiveRecord::Base)
+        super
+
+        return unless run_in_transaction?
+
+        # Replace the one that activerecord natively uses with a switchman-optimized one
+        ::ActiveSupport::Notifications.unsubscribe(@connection_subscriber)
+        # Code adapted from the code in rails proper
+        @connection_subscriber = ::ActiveSupport::Notifications.subscribe('!connection.active_record') do |_, _, _, _, payload|
+          spec_name = payload[:spec_name] if payload.key?(:spec_name)
+          shard = payload[:shard] if payload.key?(:shard)
+          setup_shared_connection_pool
+
+          if spec_name && !FORBIDDEN_DB_ENVS.include?(shard)
+            begin
+              connection = ::ActiveRecord::Base.connection_handler.retrieve_connection(spec_name, shard: shard)
+            rescue ::ActiveRecord::ConnectionNotEstablished, ::ActiveRecord::NoDatabaseError
+              connection = nil
+            end
+
+            if connection && !@fixture_connections.include?(connection)
+              connection.begin_transaction joinable: false, _lazy: false
+              connection.pool.lock_thread = true if lock_threads
+              @fixture_connections << connection
+            end
+          end
+        end
+      end
+
+      def enlist_fixture_connections
+        setup_shared_connection_pool
+
+        ::ActiveRecord::Base.connection_handler.connection_pool_list.reject { |cp| FORBIDDEN_DB_ENVS.include?(cp.db_config.env_name.to_sym) }.map(&:connection)
+      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