switchman 0.0.1 → 1.0.0

data/spec/lib/active_record/association_spec.rb

@@ -96,6 +96,15 @@ module Switchman
         relation.where_values.detect{|v| v.left.name == "id"}.right.should == [a1.local_id, a2.global_id]
       end
 
+      it "should properly set up a cross-shard-category query" do
+        @shard1.activate(:mirror_universe) do
+          mirror_user = MirrorUser.create!
+          relation = mirror_user.association(:user).scoped
+          relation.shard_value.should == Shard.default
+          relation.where_values.first.right.should == mirror_user.global_id
+        end
+      end
+
       describe "multishard associations" do
         it "should group has_many associations over associated_shards" do
           @shard1.activate{ Appendage.create!(:user_id => @user1, :value => 1) }
@@ -181,6 +190,38 @@ module Switchman
           @user1.digits.has_no_value.shard(@shard2).to_a.count.should == 0
         end
 
+        describe "unsharded associations" do
+          it "should be able to create an unsharded new record through a collection" do
+            root = @user2.roots.create!
+            root.reload
+            root.shard.should == Shard.default
+            root.user_id.should == @user2.global_id
+            root.user.should == @user2
+          end
+        end
+
+        describe "belongs_to associations" do
+          it "should identify an implied shard value based on the foreign id" do
+            @shard1.activate do
+              @appendage = Appendage.create!(:user_id => @user2.global_id)
+              @appendage.reload.user.should == @user2
+            end
+          end
+
+          it "should translate foreign keys when replacing the record" do
+            a = @shard2.activate { Appendage.create! }
+            copy = a.dup
+            @shard1.activate do
+              copy.user = @user1
+              copy.shard = @user1.shard
+              copy.save!
+              copy.reload
+              copy.user.shard.should == @shard1
+              copy.user.should == @user1
+            end
+          end
+        end
+
         describe "preloading" do
           it "should preload belongs_to associations across shards" do
             a1 = Appendage.create!(:user => @user1)

data/spec/lib/active_record/attribute_methods_spec.rb

@@ -102,6 +102,12 @@ module Switchman
             appendage.original_user_id.should == @shard2.global_id_for(6)
           end
         end
+
+        it "should not choke on polymorphic associations that are missing their type" do
+          f = Feature.create!(owner: User.create!)
+          f = Feature.select(:owner_id).where(id: f).first
+          f.owner_id
+        end
       end
     end
   end

data/spec/lib/active_record/base_spec.rb

@@ -6,17 +6,23 @@ module Switchman
       include RSpecHelper
 
       describe "to_param" do
-        it "should return nil if not persisted" do
+        it "should return nil if no id" do
           user = User.new
           user.to_param.should be_nil
         end
 
+        it "should return the id even if not persisted" do
+          user = User.new
+          user.id = 1
+          user.to_param.should == '1'
+        end
+
         it "should return local id if in the current shard" do
           user = User.create!
-          user.to_param.should == user.local_id
+          user.to_param.should == user.local_id.to_s
           @shard1.activate do
             user2 = User.create!
-            user2.to_param.should == user2.local_id
+            user2.to_param.should == user2.local_id.to_s
           end
         end
 
@@ -31,7 +37,7 @@ module Switchman
         end
 
         it "should use to_param in url helpers" do
-          helpers = Rails.application.routes.url_helpers
+          helpers = ::Rails.application.routes.url_helpers
           user = nil
           appendage = nil
 
@@ -61,6 +67,16 @@ module Switchman
           end
         end
       end
+
+      describe "shard=" do
+        it "should adjust foreign ids when shard is changed" do
+          user = User.create!
+          appendage = Appendage.new
+          appendage.user_id = user.id
+          appendage.shard = @shard1
+          appendage.attributes["user_id"].should == user.global_id
+        end
+      end
     end
   end
 end

data/spec/lib/active_record/calculations_spec.rb

@@ -114,6 +114,123 @@ module Switchman
           Appendage.where(:id => @appendages).sum(:value).should == 15
         end
       end
+
+      describe "#execute_grouped_calculation" do
+        before do
+          @appendages = []
+          @shard1.activate { @user1 = User.create!(:name => "user1") }
+          @shard2.activate { @user2 = User.create!(:name => "user2") }
+
+          @shard1.activate do
+            @appendages << Appendage.create!(:user_id => @user1.id, :value => 1)
+            @appendages << Appendage.create!(:user_id => @user2.id, :value => 3)
+          end
+          @shard2.activate do
+            @appendages << Appendage.create!(:user_id => @user1.id, :value => 2)
+            @appendages << Appendage.create!(:user_id => @user2.id, :value => 4)
+            @appendages << Appendage.create!(:user_id => @user2.id, :value => 5)
+          end
+        end
+
+        it "should calculate average across shards" do
+          Appendage.shard([@shard1, @shard2]).group("appendages.user_id").average(:value).should ==
+              {@user1.global_id => 1.5, @user2.global_id => 4}
+
+          @shard1.activate do
+            Appendage.shard([@shard1, @shard2]).group("appendages.user_id").average(:value).should ==
+                {@user1.local_id => 1.5, @user2.global_id => 4}
+          end
+
+          @shard2.activate do
+            Appendage.shard([@shard1, @shard2]).group("appendages.user_id").average(:value).should ==
+                {@user1.global_id => 1.5, @user2.local_id => 4}
+          end
+
+          Appendage.shard([@shard1, @shard2]).group(:user).average(:value).should ==
+              {@user1 => 1.5, @user2 => 4}
+        end
+
+        it "should count across shards" do
+          Appendage.shard([@shard1, @shard2]).group("appendages.user_id").count.should ==
+              {@user1.global_id => 2, @user2.global_id => 3}
+
+          @shard1.activate do
+            Appendage.shard([@shard1, @shard2]).group("appendages.user_id").count.should ==
+                {@user1.local_id => 2, @user2.global_id => 3}
+          end
+
+          @shard2.activate do
+            Appendage.shard([@shard1, @shard2]).group("appendages.user_id").count.should ==
+                {@user1.global_id => 2, @user2.local_id => 3}
+          end
+
+          Appendage.shard([@shard1, @shard2]).group(:user).count.should ==
+              {@user1 => 2, @user2 => 3}
+        end
+
+        it "should calculate minimum across shards" do
+          Appendage.shard([@shard1, @shard2]).group("appendages.user_id").minimum(:value).should ==
+              {@user1.global_id => 1, @user2.global_id => 3}
+
+          @shard1.activate do
+            Appendage.shard([@shard1, @shard2]).group("appendages.user_id").minimum(:value).should ==
+                {@user1.local_id => 1, @user2.global_id => 3}
+          end
+
+          @shard2.activate do
+            Appendage.shard([@shard1, @shard2]).group("appendages.user_id").minimum(:value).should ==
+                {@user1.global_id => 1, @user2.local_id => 3}
+          end
+
+          Appendage.shard([@shard1, @shard2]).group(:user).minimum(:value).should ==
+              {@user1 => 1, @user2 => 3}
+        end
+
+        it "should calculate maximum across shards" do
+          Appendage.shard([@shard1, @shard2]).group("appendages.user_id").maximum(:value).should ==
+              {@user1.global_id => 2, @user2.global_id => 5}
+
+          @shard1.activate do
+            Appendage.shard([@shard1, @shard2]).group("appendages.user_id").maximum(:value).should ==
+                {@user1.local_id => 2, @user2.global_id => 5}
+          end
+
+          @shard2.activate do
+            Appendage.shard([@shard1, @shard2]).group("appendages.user_id").maximum(:value).should ==
+                {@user1.global_id => 2, @user2.local_id => 5}
+          end
+
+          Appendage.shard([@shard1, @shard2]).group(:user).maximum(:value).should ==
+              {@user1 => 2, @user2 => 5}
+        end
+
+        it "should calculate sum across shards" do
+          Appendage.shard([@shard1, @shard2]).group("appendages.user_id").sum(:value).should ==
+              {@user1.global_id => 3, @user2.global_id => 12}
+
+          @shard1.activate do
+            Appendage.shard([@shard1, @shard2]).group("appendages.user_id").sum(:value).should ==
+                {@user1.local_id => 3, @user2.global_id => 12}
+          end
+
+          @shard2.activate do
+            Appendage.shard([@shard1, @shard2]).group("appendages.user_id").sum(:value).should ==
+                {@user1.global_id => 3, @user2.local_id => 12}
+          end
+
+          Appendage.shard([@shard1, @shard2]).group(:user).sum(:value).should ==
+              {@user1 => 3, @user2 => 12}
+        end
+
+        it "should respect order for a single shard" do
+          @shard1.activate do
+            @user1.appendages.create!
+            user2 = User.create!
+            user2.appendages.create!
+            Appendage.group(:user_id).order("COUNT(*) DESC").limit(1).count.should == { @user1.id => 2 }
+          end
+        end
+      end
     end
   end
 end

data/spec/lib/active_record/finder_methods_spec.rb

@@ -24,6 +24,28 @@ module Switchman
           User.find_by_id([@user.global_id]).should == @user
         end
       end
+
+      describe "#find_or_initialize" do
+        it "should initialize with the shard from the scope" do
+          @user.destroy
+          u = User.shard(@shard1).where(id: @user).first_or_initialize
+          u.should be_new_record
+          u.shard.should == @shard1
+        end
+      end
+
+      describe "#exists?" do
+        it "should work for an out-of-shard scope" do
+          scope = @shard1.activate { User.where(id: @user) }
+          scope.shard_value.should == @shard1
+          scope.exists?.should be_true
+        end
+
+        it "should work for a multi-shard scope" do
+          user2 = @shard2.activate { User.create!(name: "multi-shard exists") }
+          User.where(name: "multi-shard exists").shard(Shard.scoped).exists?.should be_true
+        end
+      end
     end
   end
 end

data/spec/lib/active_record/query_cache_spec.rb

@@ -5,6 +5,45 @@ module Switchman
     describe QueryCache do
       include RSpecHelper
 
+      # call with two blocks. the first will run on a new thread, pausing at
+      # the site of a "cc.call". the second will run on the original thread
+      # while the first is paused. the first will then finish.
+      def threaded(blk1, blk2)
+        mutex = Mutex.new
+        ready1 = ConditionVariable.new
+        ready2 = ConditionVariable.new
+
+        cc = lambda do
+          mutex.synchronize do
+            ready1.signal
+            ready2.wait(mutex)
+          end
+        end
+
+        thread = Thread.new do
+          blk1.call(cc)
+          ::ActiveRecord::Base.connection_pool.release_connection
+        end
+
+        mutex.synchronize do
+          ready1.wait(mutex)
+          blk2.call
+          ready2.signal
+        end
+
+        thread.join
+      end
+
+      before do
+        @orig_enabled = User.connection.query_cache_enabled
+        @orig_cache = User.connection.query_cache.dup
+      end
+
+      after do
+        User.connection.query_cache_enabled = @enabled
+        User.connection.instance_variable_set(:@query_cache, @orig_cache)
+      end
+
       it "should isolate queries to multiple shards on the same server" do
         @shard1.activate do
           User.create!
@@ -15,6 +54,255 @@ module Switchman
         end
         @shard1.activate { User.all }.should_not == @shard3.activate { User.all }
       end
+
+      describe "query_cache_enabled" do
+        it "should be shared across shards on the same server" do
+          @shard1.activate{ User.connection.query_cache_enabled = true }
+          @shard3.activate{ User.connection.query_cache_enabled = false }
+          @shard1.activate{ User.connection.query_cache_enabled.should == false }
+        end
+
+        it "should be shared across servers" do
+          @shard1.activate{ User.connection.query_cache_enabled = true }
+          @shard2.activate{ User.connection.query_cache_enabled = false }
+          @shard1.activate{ User.connection.query_cache_enabled.should == false }
+        end
+
+        it "should be distinct across threads" do
+          User.connection.query_cache_enabled = true
+          threaded(
+            lambda{ |cc| User.connection.query_cache_enabled = false; cc.call },
+            lambda{ User.connection.query_cache_enabled.should == true })
+        end
+      end
+
+      describe "enable_query_cache!" do
+        it "should only enable for the current thread" do
+          User.connection.query_cache_enabled = false
+          threaded(
+            lambda{ |cc|
+              User.connection.query_cache_enabled = false
+              User.connection.enable_query_cache!
+              User.connection.query_cache_enabled.should == true
+              cc.call
+            },
+            lambda{ User.connection.query_cache_enabled.should == false })
+        end
+      end
+
+      describe "disable_query_cache!" do
+        it "should only enable for the current thread" do
+          User.connection.query_cache_enabled = true
+          threaded(
+            lambda{ |cc|
+              User.connection.query_cache_enabled = true
+              User.connection.disable_query_cache!
+              User.connection.query_cache_enabled.should == false
+              cc.call
+            },
+            lambda{ User.connection.query_cache_enabled.should == true })
+        end
+      end
+
+      describe "cache" do
+        it "should only enable for the current thread" do
+          # check that query_cache_enabled stays false on this thread while
+          # another thread is in a cache{} block
+          User.connection.disable_query_cache!
+          threaded(
+            lambda{ |cc| User.connection.cache{ cc.call } },
+            lambda{ User.connection.query_cache_enabled.should == false })
+        end
+
+        it "should only enable for the duration of the block" do
+          User.connection.disable_query_cache!
+          User.connection.cache do
+            User.connection.query_cache_enabled.should == true
+          end
+          User.connection.query_cache_enabled.should == false
+        end
+
+        it "should clear query cache if disabling query cache after block" do
+          User.connection.disable_query_cache!
+          User.connection.cache do
+            User.connection.query_cache[:key][:binds] = :value
+          end
+          User.connection.query_cache[:key][:binds].should be_nil
+        end
+
+        it "should not clear query cache if the cache was already enabled" do
+          User.connection.enable_query_cache!
+          User.connection.cache do
+            User.connection.query_cache[:key][:binds] = :value
+          end
+          User.connection.query_cache[:key][:binds].should == :value
+        end
+      end
+
+      describe "uncached" do
+        it "should only disable for the current thread" do
+          # check that query_cache_enabled stays true on this thread while
+          # another thread is in an uncached{} block
+          User.connection.enable_query_cache!
+          threaded(
+            lambda{ |cc| User.connection.uncached{ cc.call } },
+            lambda{ User.connection.query_cache_enabled.should == true })
+        end
+
+        it "should only disable for the duration of the block" do
+          User.connection.enable_query_cache!
+          User.connection.uncached do
+            User.connection.query_cache_enabled.should == false
+          end
+          User.connection.query_cache_enabled.should == true
+        end
+
+        it "should not clear query cache" do
+          User.connection.query_cache[:key][:binds] = :value
+          User.connection.uncached{}
+          User.connection.query_cache[:key][:binds].should == :value
+        end
+      end
+
+      describe "select_all" do
+        it "should cache when query cache enabled" do
+          User.connection.enable_query_cache!
+          User.all
+          User.connection.query_cache.should_not be_empty
+        end
+
+        it "should not cache when query cache disabled" do
+          User.connection.disable_query_cache!
+          User.all
+          User.connection.query_cache.should be_empty
+        end
+
+        it "should not cache when query cache disabled but other thread's enabled" do
+          User.connection.disable_query_cache!
+          threaded(
+            lambda{ |cc| User.connection.cache{ cc.call } },
+            lambda{ User.all; User.connection.query_cache.should be_empty })
+        end
+
+        it "should not cache when query is locked" do
+          User.connection.enable_query_cache!
+          User.lock.all
+          User.connection.query_cache.should be_empty
+        end
+      end
+
+      describe "insert" do
+        it "should clear thread's query cache if enabled" do
+          User.connection.enable_query_cache!
+          User.all
+          User.create!
+          User.connection.query_cache.should be_empty
+        end
+
+        it "should not clear thread's query cache if disabled" do
+          User.connection.enable_query_cache!
+          User.all
+          User.connection.disable_query_cache!
+          User.create!
+          User.connection.query_cache.should_not be_empty
+        end
+
+        it "should not clear thread's query cache if disabled but other thread's enabled" do
+          User.connection.enable_query_cache!
+          User.all
+          User.connection.disable_query_cache!
+          threaded(
+            lambda{ |cc| User.create!; cc.call },
+            lambda{ User.connection.query_cache.should_not be_empty })
+        end
+
+        it "should not clear other thread's query cache" do
+          User.connection.enable_query_cache!
+          User.all
+          User.connection.disable_query_cache!
+          threaded(
+            lambda{ |cc| User.create!; cc.call },
+            lambda{ User.connection.query_cache.should_not be_empty })
+        end
+      end
+
+      describe "update" do
+        before do
+          User.create!
+        end
+
+        it "should clear thread's query cache if enabled" do
+          User.connection.enable_query_cache!
+          User.all
+          User.update_all(updated_at: Time.now)
+          User.connection.query_cache.should be_empty
+        end
+
+        it "should not clear thread's query cache if disabled" do
+          User.connection.enable_query_cache!
+          User.all
+          User.connection.disable_query_cache!
+          User.update_all(updated_at: Time.now)
+          User.connection.query_cache.should_not be_empty
+        end
+
+        it "should not clear thread's query cache if disabled but other thread's enabled" do
+          User.connection.enable_query_cache!
+          User.all
+          User.connection.disable_query_cache!
+          threaded(
+            lambda{ |cc| User.update_all(updated_at: Time.now); cc.call },
+            lambda{ User.connection.query_cache.should_not be_empty })
+        end
+
+        it "should not clear other thread's query cache" do
+          User.connection.enable_query_cache!
+          User.all
+          User.connection.disable_query_cache!
+          threaded(
+            lambda{ |cc| User.update_all(updated_at: Time.now); cc.call },
+            lambda{ User.connection.query_cache.should_not be_empty })
+        end
+      end
+
+      describe "delete" do
+        before do
+          User.create!
+        end
+
+        it "should clear thread's query cache if enabled" do
+          User.connection.enable_query_cache!
+          User.all
+          User.delete_all
+          User.connection.query_cache.should be_empty
+        end
+
+        it "should not clear thread's query cache if disabled" do
+          User.connection.enable_query_cache!
+          User.all
+          User.connection.disable_query_cache!
+          User.delete_all
+          User.connection.query_cache.should_not be_empty
+        end
+
+        it "should not clear thread's query cache if disabled but other thread's enabled" do
+          User.connection.enable_query_cache!
+          User.all
+          User.connection.disable_query_cache!
+          threaded(
+            lambda{ |cc| User.delete_all; cc.call },
+            lambda{ User.connection.query_cache.should_not be_empty })
+        end
+
+        it "should not clear other thread's query cache" do
+          User.connection.enable_query_cache!
+          User.all
+          User.connection.disable_query_cache!
+          threaded(
+            lambda{ |cc| User.delete_all; cc.call },
+            lambda{ User.connection.query_cache.should_not be_empty })
+        end
+      end
     end
   end
 end

data/spec/lib/active_record/query_methods_spec.rb

@@ -124,6 +124,39 @@ module Switchman
             relation.where_values.first.right.should == [@user1.global_id, @user2.local_id]
           end
         end
+
+        it "should translate ids in joins" do
+          relation = User.joins(:appendage).where(appendages: { user_id: [@user1, @user2]})
+          relation.where_values.first.right.should == [@user1.local_id, @user2.global_id]
+        end
+
+        it "should translate ids according to the current shard of the foreign type" do
+          @shard1.activate(:mirror_universe) do
+            mirror_user = MirrorUser.create!
+            relation = User.where(mirror_user_id: mirror_user)
+            relation.where_values.first.right.should == mirror_user.global_id
+          end
+        end
+      end
+
+      describe "with table aliases" do
+        it "should properly construct the query" do
+          child = @user1.children.create!
+          grandchild = child.children.create!
+          child.reload.parent.should == @user1
+
+          relation = @user1.association(:grandchildren).scoped
+
+          attribute = relation.where_values.first.left
+          attribute.name.to_s.should == 'parent_id'
+          attribute.relation.class.should == Arel::Nodes::TableAlias
+
+          rel, column = relation.send(:relation_and_column, attribute)
+          relation.send(:sharded_primary_key?, rel, column).should == false
+          relation.send(:sharded_foreign_key?, rel, column).should == true
+
+          @user1.grandchildren.should == [grandchild]
+        end
       end
     end
   end

data/spec/lib/active_record/relation_spec.rb

@@ -33,6 +33,15 @@ module Switchman
           @user2.reload.name.should == 'a'
         end
       end
+
+      describe "#new" do
+        it "should infer the scope's shard" do
+          scope = @shard1.activate { User.where(id: 1) }
+          u = scope.new
+          u.shard.should == @shard1
+          u.local_id.should == 1
+        end
+      end
     end
   end
 end

data/spec/lib/active_record/spawn_methods_spec.rb

@@ -0,0 +1,43 @@
+require "spec_helper"
+
+module Switchman
+  module ActiveRecord
+    describe SpawnMethods do
+      include RSpecHelper
+
+      describe "#merge" do
+        it "should merge shard_value for multiple explicits" do
+          result = User.shard([@shard1, @shard2]).merge(User.shard([Shard.default, @shard1]))
+          result.shard_value.should == @shard1
+          result.shard_source_value.should == :explicit
+        end
+
+        it "should merge shard_value relations for multiple explicits" do
+          result = User.shard(Shard.where("id IN (?)", [@shard1, @shard2])).merge(User.shard(Shard.where(id: [Shard.default, @shard1])))
+          (::ActiveRecord::Relation === result.shard_value).should be_true
+          result.shard_value.to_a.should == [@shard1]
+          result.shard_source_value.should == :explicit
+        end
+
+        it "should ignore implicit shard value lhs" do
+          result = User.scoped.merge(User.shard(@shard1))
+          result.shard_value.should == @shard1
+          result.shard_source_value.should == :explicit
+        end
+
+        it "should ignore implicit shard value rhs" do
+          result = User.shard(@shard1).merge(User.scoped)
+          result.shard_value.should == @shard1
+          result.shard_source_value.should == :explicit
+        end
+
+        it "should take lhs shard_value for double implicit" do
+          scope1 = @shard2.activate { User.scoped }
+          result = scope1.merge(User.scoped)
+          result.shard_value.should == @shard2
+          result.shard_source_value.should == :implicit
+        end
+      end
+    end
+  end
+end