switchman 1.1.0 → 1.2.0

data/lib/switchman/active_record/finder_methods.rb

@@ -42,7 +42,7 @@ module Switchman
 
         activate { return true if connection.select_value(relation, "#{name} Exists") }
         false
-      rescue ThrowResult
+      rescue ::ActiveRecord::ThrowResult
         false
       end
     end

data/lib/switchman/active_record/query_methods.rb

@@ -12,36 +12,59 @@ module Switchman
       #                  for foreign key transposition
       #   :to_a        - a special value that Relation#to_a uses when querying multiple shards to
       #                  remove primary keys from conditions that aren't applicable to the current shard
-      attr_accessor :shard_value, :shard_source_value
+      if ::Rails.version < '4'
+        attr_accessor :shard_value, :shard_source_value
+      else
+        def shard_value
+          @values[:shard]
+        end
+        def shard_source_value
+          @values[:shard_source]
+        end
+        def shard_value=(value)
+          raise ImmutableRelation if @loaded
+          @values[:shard] = value
+        end
+        def shard_source_value=(value)
+          raise ImmutableRelation if @loaded
+          @values[:shard_source] = value
+        end
+      end
 
       def shard(value, source = :explicit)
-        relation = clone
-        relation.shard_value = value
-        relation.shard_source_value = source
-        if (primary_shard != relation.primary_shard || source == :to_a)
-          relation.where_values = relation.transpose_predicates(relation.where_values, primary_shard, relation.primary_shard, source == :to_a) if !relation.where_values.empty?
-          relation.having_values = relation.transpose_predicates(relation.having_values, primary_shard, relation.primary_shard, source == :to_a) if !relation.having_values.empty?
+        (::Rails.version < '4' ? clone : spawn).shard!(value, source)
+      end
+
+      def shard!(value, source = :explicit)
+        primary_shard = self.primary_shard
+        self.shard_value = value
+        self.shard_source_value = source
+        if (primary_shard != self.primary_shard || source == :to_a)
+          self.where_values = transpose_predicates(where_values, primary_shard, self.primary_shard, source == :to_a) if !where_values.empty?
+          self.having_values = transpose_predicates(having_values, primary_shard, self.primary_shard, source == :to_a) if !having_values.empty?
         end
-        relation
+        self
       end
 
-      # replace these with versions that call build_where on the
-      # result relation, not the source relation (so build_where
-      # is able to implicitly change the shard_value)
-      def where(opts, *rest)
-        return self if opts.blank?
+      if ::Rails.version < '4'
+        # replace these with versions that call build_where on the
+        # result relation, not the source relation (so build_where
+        # is able to implicitly change the shard_value)
+        def where(opts, *rest)
+          return self if opts.blank?
 
-        relation = clone
-        relation.where_values += relation.build_where(opts, rest)
-        relation
-      end
+          relation = clone
+          relation.where_values += relation.build_where(opts, rest)
+          relation
+        end
 
-      def having(opts, *rest)
-        return self if opts.blank?
+        def having(opts, *rest)
+          return self if opts.blank?
 
-        relation = clone
-        relation.having_values += relation.build_where(opts, rest)
-        relation
+          relation = clone
+          relation.having_values += relation.build_where(opts, rest)
+          relation
+        end
       end
 
       def build_where(opts, other = [])
@@ -147,6 +170,7 @@ module Switchman
       end
 
       def sharded_primary_key?(relation, column)
+        return column == 'id' if relation.engine == ::ActiveRecord::Base
         relation.engine.primary_key == column
       end
 
@@ -165,6 +189,7 @@ module Switchman
         attribute = attribute.relation if attribute.relation.is_a?(Arel::Nodes::TableAlias)
         [attribute.relation, column]
       end
+
       # semi-private
       public
       def transpose_predicates(predicates, source_shard, target_shard, remove_nonlocal_primary_keys = false)
@@ -194,11 +219,11 @@ module Switchman
             local_ids
           when Arel::Nodes::BindParam
             # look for a bind param with a matching column name
-            if @bind_params && idx = @bind_params.find_index{|b| b.is_a?(Array) && b.first.try(:name) == predicate.left}
-              column, value = @bind_params[idx]
+            if bind_values && idx = bind_values.find_index{|b| b.is_a?(Array) && b.first.try(:name) == predicate.left.name}
+              column, value = bind_values[idx]
               local_id = Shard.relative_id_for(value, current_source_shard, target_shard)
               local_id = [] if remove && local_id > Shard::IDS_PER_SHARD
-              @bind_params[idx] = [column, local_id]
+              bind_values[idx] = [column, local_id]
             end
             predicate.right
           else

data/lib/switchman/active_record/relation.rb

@@ -13,10 +13,10 @@ module Switchman
         end
       end
 
-      def initialize_with_sharding(klass, table)
-        initialize_without_sharding(klass, table)
-        self.shard_value = Shard.current(klass.shard_category)
-        self.shard_source_value = :implicit
+      def initialize_with_sharding(*args)
+        initialize_without_sharding(*args)
+        self.shard_value = Shard.current(klass.try(:shard_category) || :default) unless shard_value
+        self.shard_source_value = :implicit unless shard_source_value
       end
 
       def merge(*args)

data/lib/switchman/active_record/spawn_methods.rb

@@ -1,17 +1,13 @@
 module Switchman
   module ActiveRecord
     module SpawnMethods
-      def merge(r)
-        return self unless r
-        return to_a & r if r.is_a?(Array)
-
-        # have to figure out shard stuff *before* conditions are merged
+      def shard_values_for_merge(r)
         if shard_value != r.shard_value
-          if (r.shard_source_value == :implicit)
+          if r.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)
+          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
@@ -30,7 +26,6 @@ module Switchman
               final_primary_shard = Shard.default
             else
               final_shard_value = lhs_shard_value.to_a & rhs_shard_value.to_a
-              return none if final_shard_value.length == 0
               final_primary_shard = final_shard_value.first
               final_shard_value = final_shard_value.first if final_shard_value.length == 1
             end
@@ -40,34 +35,86 @@ module Switchman
             shard_source_value == source_value || r.shard_source_value == source_value
           end
           raise "unknown shard_source_value" unless final_shard_source_value
-
-          result = super
-          result.shard_source_value = final_shard_source_value
-          return result
         else
           # nothing fancy
-          return super
         end
 
-        # change the primary shard if necessary before merging
-        result = if primary_shard != final_primary_shard && r.primary_shard != final_primary_shard
-          lhs = shard(final_primary_shard)
-          r = r.shard(final_primary_shard)
-          lhs.merge(r)
-        elsif primary_shard != final_primary_shard
-          lhs = shard(final_primary_shard)
-          lhs.merge(r)
-        elsif r.primary_shard != final_primary_shard
-          r = r.shard(final_primary_shard)
-          super(r)
-        else
-          super
+        [final_shard_value, final_primary_shard, final_shard_source_value]
+      end
+
+      if ::Rails.version < '4'
+        def merge(r)
+          return self unless r
+          return super unless r.is_a?(Relation)
+
+          # 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)
+
+          return super unless final_shard_source_value
+
+          if !final_shard_value
+            result = super
+            result.shard_source_value = final_shard_source_value
+            return result
+          end
+
+          return none if final_shard_value == []
+
+          # change the primary shard if necessary before merging
+          result = if primary_shard != final_primary_shard && r.primary_shard != final_primary_shard
+                     lhs = shard(final_primary_shard)
+                     r = r.shard(final_primary_shard)
+                     lhs.merge(r)
+                   elsif primary_shard != final_primary_shard
+                     lhs = shard(final_primary_shard)
+                     lhs.merge(r)
+                   elsif r.primary_shard != final_primary_shard
+                     r = r.shard(final_primary_shard)
+                     super(r)
+                   else
+                     super
+                   end
+
+          result.shard_value = final_shard_value
+          result.shard_source_value = final_shard_source_value
+
+          result
         end
+      else
+        def merge!(r)
+          # 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)
+
+          return super unless final_shard_source_value
+
+          if !final_shard_value
+            super
+            self.shard_source_value = final_shard_source_value
+            return self
+          end
 
-        result.shard_value = final_shard_value
-        result.shard_source_value = final_shard_source_value
+          return none! if final_shard_value == []
 
-        result
+          # change the primary shard if necessary before merging
+          if primary_shard != final_primary_shard && r.primary_shard != final_primary_shard
+            shard!(final_primary_shard)
+            r = r.shard(final_primary_shard)
+            super(r)
+          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)
+          else
+            super
+          end
+
+          self.shard_value = final_shard_value
+          self.shard_source_value = final_shard_source_value
+
+          self
+        end
       end
     end
   end

data/lib/switchman/connection_pool_proxy.rb

@@ -91,7 +91,8 @@ module Switchman
           end
         end
       end
-      spec = ::ActiveRecord::Base::ConnectionSpecification.new(config, "#{config[:adapter]}_connection")
+      klass = ::Rails.version < '4' ? ::ActiveRecord::Base : ::ActiveRecord::ConnectionAdapters
+      spec = klass::ConnectionSpecification.new(config, "#{config[:adapter]}_connection")
       # unfortunately the AR code that does this require logic can't really be
       # called in isolation
       require "active_record/connection_adapters/#{config[:adapter]}_adapter"

data/lib/switchman/database_server.rb

@@ -125,7 +125,7 @@ module Switchman
     end
 
     def create_new_shard(options = {})
-      raise MethodNotImplemented unless Shard.default.is_a?(Shard)
+      raise NotImplementedError.new("Cannot create new shards when sharding isn't initialized") unless Shard.default.is_a?(Shard)
 
       db_name = options[:db_name]
       create_schema = options[:schema]
@@ -193,13 +193,15 @@ module Switchman
                     ::ActiveRecord::Base.connection.execute(stmt)
                   end
                   # have to disconnect and reconnect to the correct db
+                  shard.name = db_name
                   if self.shareable? && other_shard
                     other_shard.activate { ::ActiveRecord::Base.connection }
                   else
                     ::ActiveRecord::Base.connection_pool.current_pool.disconnect!
                   end
+                else
+                  shard.name = db_name
                 end
-                shard.name = db_name
                 old_proc = ::ActiveRecord::Base.connection.raw_connection.set_notice_processor {} if config[:adapter] == 'postgresql'
                 old_verbose = ::ActiveRecord::Migration.verbose
                 ::ActiveRecord::Migration.verbose = false

data/lib/switchman/engine.rb

@@ -75,7 +75,7 @@ module Switchman
         ::ActiveRecord::Associations::Association.send(:include, ActiveRecord::Association)
         ::ActiveRecord::Associations::BelongsToAssociation.send(:include, ActiveRecord::BelongsToAssociation)
         ::ActiveRecord::Associations::CollectionProxy.send(:include, ActiveRecord::CollectionProxy)
-        ::ActiveRecord::Associations::Builder::Association.send(:include, ActiveRecord::Builder::Association)
+        ::ActiveRecord::Associations::Builder::CollectionAssociation.send(:include, ActiveRecord::Builder::CollectionAssociation)
 
         ::ActiveRecord::Associations::Preloader::Association.send(:include, ActiveRecord::Preloader::Association)
         ::ActiveRecord::ConnectionAdapters::AbstractAdapter.send(:include, ActiveRecord::AbstractAdapter)

data/lib/switchman/r_spec_helper.rb

@@ -96,9 +96,13 @@ module Switchman
           shards.each do |shard|
             shard.activate do
               # this is how AR does it in fixtures.rb
-              ::ActiveRecord::Base.connection.increment_open_transactions
-              ::ActiveRecord::Base.connection.transaction_joinable = false
-              ::ActiveRecord::Base.connection.begin_db_transaction
+              if ::Rails.version < '4'
+                ::ActiveRecord::Base.connection.increment_open_transactions
+                ::ActiveRecord::Base.connection.transaction_joinable = false
+                ::ActiveRecord::Base.connection.begin_db_transaction
+              else
+                ::ActiveRecord::Base.connection.begin_transaction joinable: false
+              end
             end
           end
         end
@@ -110,9 +114,13 @@ module Switchman
           shards << @shard1 unless @shard1.database_server == Shard.default.database_server
           shards.each do |shard|
             shard.activate do
-              if ::ActiveRecord::Base.connection.open_transactions != 0
-                ::ActiveRecord::Base.connection.rollback_db_transaction
-                ::ActiveRecord::Base.connection.decrement_open_transactions
+              if ::Rails.version < '4'
+                if ::ActiveRecord::Base.connection.open_transactions != 0
+                  ::ActiveRecord::Base.connection.rollback_db_transaction
+                  ::ActiveRecord::Base.connection.decrement_open_transactions
+                end
+              else
+                ::ActiveRecord::Base.connection.rollback_transaction if ::ActiveRecord::Base.connection.transaction_open?
               end
             end
           end

data/lib/switchman/rails.rb

@@ -1,21 +1,19 @@
 module Switchman::Rails
   module ClassMethods
-    def cache_with_sharding
+    def cache
       Switchman::Shard.current.database_server.cache_store
     end
+  end
+
+  def self.included(klass)
+    klass.extend(ClassMethods)
+    klass.singleton_class.send(:remove_method, :cache)
 
     # in Rails 4+, the Rails.cache= method was used during bootstrap to set
     # Rails.cache(_without_sharding) to the value from the config file. but now
     # that that's done (the bootstrap happened before this module is included
     # into Rails), we want to make sure no one tries to assign to Rails.cache,
     # because it would be wrong w.r.t. sharding.
-    def cache=(new_cache)
-      raise NoMethodError
-    end
-  end
-
-  def self.included(klass)
-    klass.extend(ClassMethods)
-    klass.singleton_class.alias_method_chain :cache, :sharding
+    klass.singleton_class.send(:remove_method, :cache=) if ::Rails.version >= '4'
   end
 end

data/lib/switchman/test_helper.rb

@@ -5,9 +5,9 @@ module Switchman
         # recreate the default shard (it got buhleted)
         if Shard.default(true).is_a?(DefaultShard)
           begin
-            Shard.create!(:default => true)
+            Shard.create!(default: true)
           rescue
-            # database doesn't exist yet, presumably
+            # database doesn't exist yet, presumably cause we're creating it right now
             [nil, nil]
           end
           Shard.default(true)
@@ -15,7 +15,8 @@ module Switchman
 
         # can't auto-create a new shard on the default shard's db server if the
         # default shard is split across multiple db servers
-        if ::ActiveRecord::Base.connection_handler.connection_pools.length > 1
+        if (::Rails.version < '4' ? ::ActiveRecord::Base.connection_handler.connection_pools.length :
+            ::ActiveRecord::Base.connection_handler.connection_pool_list.length) > 1
           server1 = DatabaseServer.create(:config => Shard.default.database_server.config)
         else
           server1 = Shard.default.database_server

data/lib/switchman/version.rb

@@ -1,3 +1,3 @@
 module Switchman
-  VERSION = "1.1.0"
+  VERSION = "1.2.0"
 end

data/spec/dummy/app/models/appendage.rb

@@ -1,13 +1,11 @@
 class Appendage < ActiveRecord::Base
-  attr_accessible :user, :user_id, :value
-
   belongs_to :user
   has_many :digits
 
   has_many :features, :as => :owner
 
-  scope :has_no_value, where(:value => nil)
-  scope :has_value, where("appendages.value IS NOT NULL")
+  scope :has_no_value, -> { where(:value => nil) }
+  scope :has_value, -> { where("appendages.value IS NOT NULL") }
 
   attr_writer :associated_shards
   class << self

data/spec/dummy/app/models/digit.rb

@@ -1,9 +1,7 @@
 class Digit < ActiveRecord::Base
-  attr_accessible :appendage, :appendage_id, :value
-
   belongs_to :appendage
   has_one :user, :through => :appendage
 
-  scope :has_no_value, where(:value => nil)
-  scope :has_value, where("digits.value IS NOT NULL")
+  scope :has_no_value, -> { where(:value => nil) }
+  scope :has_value, -> { where("digits.value IS NOT NULL") }
 end

data/spec/dummy/app/models/feature.rb

@@ -1,5 +1,3 @@
 class Feature < ActiveRecord::Base
   belongs_to :owner, :polymorphic => true
-
-  attr_accessible :owner, :value
 end