replica_pools 2.0.1 → 2.1.0.rc2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: edb39e7bba943456f9c6262e532183226db89ae5
-  data.tar.gz: 2a3b2c05e8de8f682ce09da5941f13eb8385ff0f
+  metadata.gz: e3df5165498dd9d834fffadadd11d0f41b032457
+  data.tar.gz: 4691bbf3ad9e4390c0bc3c76a388cb1e1fecec9c
 SHA512:
-  metadata.gz: 68cbf573d8ab894e5681688b1f65b66d66362560f6573d53c9a3afe56e4e33df1749054a3df048657761f2056294ff9059b1356b267ed4b394548473cea574c2
-  data.tar.gz: f64db9a4da50eee2203958b21c0a59b66f2339adad4ec3f607dbd2fcdb28804691ecce83bf800a418b55f237288ea55c13b8c1f7b053d68509e6ad5f3d80b214
+  metadata.gz: 75dafb6740e7d0bc705a8bc57848acfb1d68161856f237ee6589a6010733f19badcf5e0502c232811782c25e8580c91d1162b98997b430cfc3814617ddca7a87
+  data.tar.gz: c6c745c869475560a5f07c5c33b5e3118d569e6891188c99600483a056a8ef540890d24e75201774a857d46eb8955b09aacf080be711f777add018bd8126ae9d

data/lib/replica_pools/engine.rb

@@ -21,6 +21,12 @@ module ReplicaPools
             :select_rows, :select, :verify!, :raw_connection, :active?, :reconnect!,
             :disconnect!, :reset_runtime, :log
           ]
+        elsif ActiveRecord::VERSION::MAJOR == 5
+          [
+           :select_all, :select_one, :select_value, :select_values,
+           :select_rows, :select, :select_prepared, :verify!, :raw_connection,
+           :active?, :reconnect!, :disconnect!, :reset_runtime, :log
+          ]
         else
           warn "Unsupported ActiveRecord version #{ActiveRecord.version}. Please whitelist the safe methods."
         end

data/lib/replica_pools/query_cache.rb

@@ -20,12 +20,30 @@ module ReplicaPools
     # select_all is trickier. it needs to use the leader
     # connection for cache logic, but ultimately pass its query
     # through to whatever connection is current.
-    def select_all(arel, name = nil, binds = [])
-      if query_cache_enabled && !locked?(arel)
-        sql = to_sql(arel, binds)
-        cache_sql(sql, binds) { route_to(current, :select_all, sql, name, binds) }
+    def select_all(*args)
+      # there may be more args for Rails 5.0+, but we only care about arel, name, and binds for caching.
+      relation, name, raw_binds = args
+
+      if !query_cache_enabled || locked?(relation)
+        return route_to(current, :select_all, *args)
+      end
+
+      # duplicate binds_from_relation behavior introduced in 4.2.
+      if raw_binds.blank? && relation.is_a?(ActiveRecord::Relation)
+        arel, binds = relation.arel, relation.bind_values
+      else
+        arel, binds = relation, raw_binds
+      end
+
+      sql = to_sql(arel, binds)
+
+      args[0] = sql
+      args[2] = binds
+
+      if Gem::Version.new(ActiveRecord.version) < Gem::Version.new('5.1')
+        cache_sql(sql, binds) { route_to(current, :select_all, *args) }
       else
-        route_to(current, :select_all, arel, name, binds)
+        cache_sql(sql, name, binds) { route_to(current, :select_all, *args) }
       end
     end
 

data/lib/replica_pools/version.rb

@@ -1,3 +1,3 @@
 module ReplicaPools
-  VERSION = "2.0.1"
+  VERSION = "2.1.0.rc2"
 end

data/spec/query_cache_spec.rb

@@ -45,42 +45,62 @@ describe ReplicaPools::QueryCache do
   end
 
   describe "using querycache middleware" do
-    it 'should cache queries using select_all' do
-      mw = ActiveRecord::QueryCache.new lambda { |env|
-        @default_replica1.should_receive(:select_all).exactly(1).and_return([])
-        @default_replica2.should_not_receive(:select_all)
-        @leader.should_not_receive(:select_all)
-        3.times { @proxy.select_all(@sql) }
-        @proxy.next_replica!
-        3.times { @proxy.select_all(@sql) }
-        @proxy.next_replica!
-        3.times { @proxy.select_all(@sql)}
+    select_all_queries_lambda = lambda do |env|
+      @default_replica1.should_receive(:select_all).exactly(1).and_return([])
+      @default_replica2.should_not_receive(:select_all)
+      @leader.should_not_receive(:select_all)
+      3.times { @proxy.select_all(@sql) }
+      @proxy.next_replica!
+      3.times { @proxy.select_all(@sql) }
+      @proxy.next_replica!
+      3.times { @proxy.select_all(@sql)}
+      @leader.query_cache.keys.size.should == 1
+      [200, {}, nil]
+    end
+
+    insert_update_delete_lambda = lambda do |env|
+      meths = [:insert, :update, :delete, :insert, :update]
+      meths.each do |meth|
+        @leader.should_receive("exec_#{meth}").and_return(true)
+      end
+
+      @default_replica1.should_receive(:select_all).exactly(5).and_return([])
+      @default_replica2.should_receive(:select_all).exactly(0)
+      5.times do |i|
+        @proxy.select_all(@sql)
+        @proxy.select_all(@sql)
         @leader.query_cache.keys.size.should == 1
-        [200, {}, nil]
-      }
-      mw.call({})
+        @proxy.send(meths[i], '')
+        @leader.query_cache.keys.size.should == 0
+      end
+      [200, {}, nil]
+    end
+
+    def executor
+      @executor ||= Class.new(ActiveSupport::Executor).tap do |exe|
+        ActiveRecord::QueryCache.install_executor_hooks(exe)
+      end
     end
 
-    it 'should invalidate the cache on insert, delete and update' do
-      mw = ActiveRecord::QueryCache.new lambda { |env|
-        meths = [:insert, :update, :delete, :insert, :update]
-        meths.each do |meth|
-          @leader.should_receive("exec_#{meth}").and_return(true)
-        end
+    if Gem::Version.new(ActiveRecord.version) < Gem::Version.new('5.0')
 
-        @default_replica1.should_receive(:select_all).exactly(5).and_return([])
-        @default_replica2.should_receive(:select_all).exactly(0)
-        5.times do |i|
-          @proxy.select_all(@sql)
-          @proxy.select_all(@sql)
-          @leader.query_cache.keys.size.should == 1
-          @proxy.send(meths[i], '')
-          @leader.query_cache.keys.size.should == 0
-        end
-        [200, {}, nil]
-      }
-      mw.call({})
+      it 'should cache queries using select_all' do
+        mw = ActiveRecord::QueryCache.new(select_all_queries_lambda)
+        mw.call({})
+      end
+
+      it 'should invalidate the cache on insert, delete and update' do
+        mw = ActiveRecord::QueryCache.new(insert_update_delete_lambda)
+        mw.call({})
+      end
+    else
+      it 'should cache queries using select_all' do
+        executor.wrap { select_all_queries_lambda }
+      end
+
+      it 'should invalidate the cache on insert, delete and update' do
+        executor.wrap { insert_update_delete_lambda }
+      end
     end
   end
-
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: replica_pools
 version: !ruby/object:Gem::Version
-  version: 2.0.1
+  version: 2.1.0.rc2
 platform: ruby
 authors:
 - Dan Drabik
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-09-28 00:00:00.000000000 Z
+date: 2017-07-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -139,7 +139,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '1.2'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.8
+rubygems_version: 2.4.5.2
 signing_key: 
 specification_version: 4
 summary: Connection proxy for ActiveRecord for leader / replica setups.