switchman 1.9.0 → 1.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d2e63c8b9d8a43c1cf8716f775593bc0e5c7296b
-  data.tar.gz: c4cda98c0bbdf18d0c648adcf8d8465c90f2246e
+  metadata.gz: d9bf082be6cc36e99b6be46bdf90c47102c45962
+  data.tar.gz: 105fd5544f11577cd939de766a0d2950f727759e
 SHA512:
-  metadata.gz: f2e7e0889dce714d0d128eeca5b09434ba0cd313ebe9e09db2f1d58e7d706e6aa1353e03b54496d2f145fbd19467c74bd095870025eb6fca0321170c06ffd14a
-  data.tar.gz: e0614890e323dcedd8b272e1ec571be80de1640d27601d9c905208e4fca69931676ec03e4ef038775aa634e43751909bdf0b18f261fe32b1c8a394764c830d24
+  metadata.gz: 3a69a13d8922e15c57a972c4521833f0d1658d7c13198f766e1cc2374a3cc8781765984194bb1b57950b32bc2c52221b3aeb8d1e6474e30bde3a4aa30a6d8cd3
+  data.tar.gz: a22298dbbc075b8a69af90bd87c97a74ad598729551f268a7bd3bb9eae08aa28eec6ca1654bf35b2b7863527acd2aab63458a8ad439453d4d86fb5514c0d7447

data/app/models/switchman/shard.rb

@@ -8,4 +8,4 @@ ActiveRecord::Base
 # we need to make sure we define the class someone wanted (in which case
 # AR's on_load hook won't be called either yet, and establish_connection
 # will be safe)
-require 'switchman/shard_internal'
+require_dependency 'switchman/shard_internal'

data/app/models/switchman/shard_internal.rb

@@ -26,6 +26,7 @@ module Switchman
     validates_uniqueness_of :default, :if => lambda { |s| s.default? }
 
     after_save :clear_cache
+    after_destroy :clear_cache
 
     scope :primary, -> { where(name: nil).order(:database_server_id, :id).distinct_on(:database_server_id) }
 
@@ -191,14 +192,14 @@ module Switchman
           max_procs = determine_max_procs(options.delete(:max_procs), parallel)
           if ::ActiveRecord::Relation === scope
             # still need a post-uniq, cause the default database server could be NULL or Rails.env in the db
-            database_servers = scope.reorder('database_server_id').select(:database_server_id).uniq.
+            database_servers = scope.reorder('database_server_id').select(:database_server_id).distinct.
                 map(&:database_server).compact.uniq
             parallel = [(max_procs.to_f / database_servers.count).ceil, parallel].min if max_procs
 
             scopes = Hash[database_servers.map do |server|
               server_scope = server.shards.merge(scope)
               if parallel == 1
-                subscopes = server_scope
+                subscopes = [server_scope]
               else
                 subscopes = []
                 total = server_scope.count
@@ -223,6 +224,8 @@ module Switchman
               scopes = Hash[scopes.map do |(server, shards)|
                 [server, shards.in_groups(parallel, false).compact]
               end]
+            else
+              scopes = Hash[scopes.map { |(server, shards)| [server, [shards]] }]
             end
           end
 
@@ -250,7 +253,7 @@ module Switchman
 
           # only one process; don't bother forking
           if scopes.length == 1 && parallel == 1
-            return with_each_shard(scopes.first.last, categories, options) { yield }
+            return with_each_shard(scopes.first.last.first, categories, options) { yield }
           end
 
           # clear connections prior to forking (no more queries will be executed in the parent,
@@ -259,10 +262,6 @@ module Switchman
           ::ActiveRecord::Base.clear_all_connections!
 
           scopes.each do |server, subscopes|
-            if !(::ActiveRecord::Relation === subscopes.first) && subscopes.first.class != Array
-              subscopes = [subscopes]
-            end
-
             subscopes.each_with_index do |subscope, idx|
               if subscopes.length > 1
                 name = "#{server.id} #{idx + 1}"
@@ -274,7 +273,7 @@ module Switchman
               exception_pipes << exception_pipe
               pid, io_in, io_out, io_err = Open4.pfork4(lambda do
                 begin
-                  Switchman.config[:on_fork_proc].try(:call)
+                  Switchman.config[:on_fork_proc]&.call
                   $0 = [$0, ARGV, name].flatten.join(' ')
                   with_each_shard(subscope, categories, options) { yield }
                   exception_pipe.last.close
@@ -349,8 +348,7 @@ module Switchman
         previous_shard = nil
         close_connections_if_needed = lambda do |shard|
           # prune the prior connection unless it happened to be the same
-          if previous_shard && shard != previous_shard &&
-            (shard.database_server != previous_shard.database_server || !previous_shard.database_server.shareable?)
+          if previous_shard && shard != previous_shard && !previous_shard.database_server.shareable?
             previous_shard.activate do
               ::Shackles.activated_environments.each do |env|
                 ::Shackles.activate(env) do
@@ -610,7 +608,7 @@ module Switchman
       begin
         adapter = self.database_server.config[:adapter]
         sharding_config = Switchman.config || {}
-        drop_statement = sharding_config[adapter].try(:[], :drop_statement)
+        drop_statement = sharding_config[adapter]&.[](:drop_statement)
         drop_statement ||= sharding_config[:drop_statement]
         if drop_statement
           drop_statement = Array(drop_statement).dup.

data/db/migrate/20130328212039_create_switchman_shards.rb

@@ -1,4 +1,4 @@
-class CreateSwitchmanShards < ActiveRecord::Migration
+class CreateSwitchmanShards < ActiveRecord::Migration[4.2]
   def change
     create_table :switchman_shards do |t|
       t.string :name

data/db/migrate/20130328224244_create_default_shard.rb

@@ -1,4 +1,4 @@
-class CreateDefaultShard < ActiveRecord::Migration
+class CreateDefaultShard < ActiveRecord::Migration[4.2]
   def up
     unless Switchman::Shard.default.is_a?(Switchman::Shard)
       Switchman::Shard.reset_column_information

data/db/migrate/20161206323434_add_back_default_string_limits_switchman.rb

@@ -1,4 +1,4 @@
-class AddBackDefaultStringLimitsSwitchman < ActiveRecord::Migration
+class AddBackDefaultStringLimitsSwitchman < ActiveRecord::Migration[4.2]
   def up
     add_string_limit_if_missing :switchman_shards, :name
     add_string_limit_if_missing :switchman_shards, :database_server_id

data/lib/switchman/active_record/abstract_adapter.rb

@@ -38,6 +38,14 @@ module Switchman
       ensure
         @last_query_at = Time.now
       end
+
+      private
+
+      def id_value_for_database(value)
+        return super unless value.class.sharded_primary_key?
+        # do this the Rails 4.2 way, so that if Shard.current != self.shard, the id gets transposed
+        quote(value.id)
+      end
     end
   end
 end

data/lib/switchman/active_record/association.rb

@@ -36,14 +36,17 @@ module Switchman
     end
 
     module CollectionAssociation
-      def get_records
-        shards = reflection.options[:multishard] && owner.respond_to?(:associated_shards) ? owner.associated_shards : [shard]
-        # activate both the owner and the target's shard category, so that Reflection#join_id_for,
-        # when called for the owner, will be returned relative to shard the query will execute on
-        Shard.with_each_shard(shards, [klass.shard_category, owner.class.shard_category].uniq) do
-          super
+      method = ::Rails.version < '5.1' ? :get_records : :find_target
+      module_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def #{method}
+          shards = reflection.options[:multishard] && owner.respond_to?(:associated_shards) ? owner.associated_shards : [shard]
+          # activate both the owner and the target's shard category, so that Reflection#join_id_for,
+          # when called for the owner, will be returned relative to shard the query will execute on
+          Shard.with_each_shard(shards, [klass.shard_category, owner.class.shard_category].uniq) do
+            super
+          end
         end
-      end
+      RUBY
     end
 
     module BelongsToAssociation
@@ -169,6 +172,12 @@ module Switchman
     end
 
     module CollectionProxy
+      def initialize(*args)
+        super
+        self.shard_value = scope.shard_value
+        self.shard_source_value = :association
+      end
+
       def shard(*args)
         scope.shard(*args)
       end

data/lib/switchman/active_record/attribute_methods.rb

@@ -27,7 +27,7 @@ module Switchman
         def reflection_for_integer_attribute(attr_name)
           attr_name = attr_name.to_s
           columns_hash[attr_name] && columns_hash[attr_name].type == :integer &&
-              reflections.find { |_, r| r.belongs_to? && r.foreign_key.to_s == attr_name }.try(:last)
+              reflections.find { |_, r| r.belongs_to? && r.foreign_key.to_s == attr_name }&.last
         rescue ::ActiveRecord::StatementInvalid
           # this is for when models are referenced in initializers before migrations have been run
           raise if connection.open_transactions > 0
@@ -65,8 +65,8 @@ module Switchman
           if reflection
             if reflection.options[:polymorphic]
               # a polymorphic association has to be discovered at runtime. This code ends up being something like
-              # context_type.try(:constantize).try(:shard_category) || :primary
-              "read_attribute(:#{reflection.foreign_type}).try(:constantize).try(:shard_category) || :primary"
+              # context_type.&.constantize&.shard_category || :primary
+              "read_attribute(:#{reflection.foreign_type})&.constantize&.shard_category || :primary"
             else
               # otherwise we can just return a symbol for the statically known type of the association
               reflection.klass.shard_category.inspect

data/lib/switchman/active_record/base.rb

@@ -33,7 +33,7 @@ module Switchman
 
         def integral_id?
           if @integral_id == nil
-            @integral_id = columns_hash[primary_key].try(:type) == :integer
+            @integral_id = columns_hash[primary_key]&.type == :integer
           end
           @integral_id
         end
@@ -105,7 +105,7 @@ module Switchman
       end
 
       def scope_class
-        self.class.base_class
+        ::Rails.version >= '5' ? self.class : self.class.base_class
       end
 
       def save(*args)
@@ -138,7 +138,7 @@ module Switchman
       end
 
       def hash
-        self.class.sharded_primary_key? ? Shard.global_id_for(id).hash : super
+        self.class.sharded_primary_key? ? self.class.hash ^ Shard.global_id_for(id).hash : super
       end
 
       def to_param
@@ -151,6 +151,14 @@ module Switchman
         @shard_set_in_stone = false
         copy
       end
+
+      if ::Rails.version >= '5'
+        def quoted_id
+          return super unless self.class.sharded_primary_key?
+          # do this the Rails 4.2 way, so that if Shard.current != self.shard, the id gets transposed
+          self.class.connection.quote(id)
+        end
+      end
     end
   end
 end

data/lib/switchman/active_record/connection_handler.rb

@@ -40,10 +40,15 @@ module Switchman
           Shard.default
 
           # automatically change config to allow for sharing connections with simple config
-          ConnectionHandler.make_sharing_automagic(spec.config)
+          config = ::Rails.version < '5.1' ? spec.config : pool.spec.config
+          ConnectionHandler.make_sharing_automagic(config)
           ConnectionHandler.make_sharing_automagic(Shard.default.database_server.config)
 
-          ::ActiveRecord::Base.configurations[::Rails.env] = spec.instance_variable_get(:@config).stringify_keys
+          if ::Rails.version < '5.1'
+            ::ActiveRecord::Base.configurations[::Rails.env] = spec.instance_variable_get(:@config).stringify_keys
+          else
+            ::ActiveRecord::Base.configurations[::Rails.env] = config.stringify_keys
+          end
         end
 
         @shard_connection_pools ||= { [:master, Shard.default.database_server.shareable? ? ::Rails.env : Shard.default] => pool}
@@ -162,12 +167,13 @@ module Switchman
               # A connection was established in an ancestor process that must have
               # subsequently forked. We can't reuse the connection, but we can copy
               # the specification and establish a new connection with it.
-              pool = nil
-              if ancestor_pool.is_a?(ConnectionPoolProxy)
-                pool = establish_connection ancestor_pool.default_pool.spec
+              spec = if ancestor_pool.is_a?(ConnectionPoolProxy)
+                ancestor_pool.default_pool.spec
               else
-                pool = establish_connection ancestor_pool.spec
+                ancestor_pool.spec
               end
+              spec = spec.to_hash if ::Rails.version >= '5.1'
+              pool = establish_connection spec
               pool.instance_variable_set(:@schema_cache, ancestor_pool.schema_cache) if ancestor_pool.schema_cache
               pool
             elsif spec_name != "primary"

data/lib/switchman/active_record/log_subscriber.rb

@@ -17,13 +17,16 @@ module Switchman
         shard = "  [#{shard[:database_server_id]}:#{shard[:id]} #{shard[:env]}]" if shard
 
         unless (payload[:binds] || []).empty?
-          binds = "  " + payload[:binds].map { |col,v|
-            if col
-              [col.name, v]
-            else
-              [nil, v]
-            end
-          }.inspect
+          if ::Rails.version < '5'
+            binds = "  " + payload[:binds].map { |col,v|
+              render_bind(col, v)
+            }.inspect
+          else
+            casted_params = type_casted_binds(payload[:binds], payload[:type_casted_binds])
+            binds = "  " + payload[:binds].zip(casted_params).map { |attr, value|
+              render_bind(attr, value)
+            }.inspect
+          end
         end
 
         if ::Rails.version >= '5'

data/lib/switchman/active_record/migration.rb

@@ -0,0 +1,37 @@
+module Switchman
+  module ActiveRecord
+    module Migration
+      module Compatibility
+        module V5_0
+          def create_table(*args, **options)
+            unless options.key?(:id)
+              options[:id] = :bigserial
+            end
+            if block_given?
+              super do |td|
+                yield td
+              end
+            else
+              super
+            end
+          end
+        end
+      end
+
+      def connection
+        conn = super
+        if conn.shard != ::ActiveRecord::Base.connection_pool.current_pool.shard
+          ::ActiveRecord::Base.connection_pool.current_pool.switch_database(conn)
+        end
+        conn
+      end
+    end
+
+    module Migrator
+      def generate_migrator_advisory_lock_id
+        shard_name_hash = Zlib.crc32(Shard.current.name)
+        ::ActiveRecord::Migrator::MIGRATOR_SALT * shard_name_hash
+      end
+    end
+  end
+end

data/lib/switchman/active_record/postgresql_adapter.rb

@@ -1,8 +1,10 @@
 module Switchman
   module ActiveRecord
     module PostgreSQLAdapter
-      def self.prepended(klass)
-        klass::NATIVE_DATABASE_TYPES[:primary_key] = "bigserial primary key".freeze
+      if ::Rails.version < '5'
+        def self.prepended(klass)
+          klass::NATIVE_DATABASE_TYPES[:primary_key] = "bigserial primary key".freeze
+        end
       end
 
       # copy/paste; use quote_local_table_name
@@ -137,7 +139,7 @@ module Switchman
         end.compact
       end
 
-      def index_name_exists?(table_name, index_name, default)
+      def index_name_exists?(table_name, index_name, _default = nil)
         schema = shard.name if use_qualified_names?
 
         exec_query(<<-SQL, 'SCHEMA').rows.first[0].to_i > 0
@@ -205,6 +207,12 @@ module Switchman
           ::ActiveRecord::ConnectionAdapters::ForeignKeyDefinition.new(table_name, to_table, options)
         end
       end
+
+      def add_index_options(_table_name, _column_name, _options = {})
+        index_name, index_type, index_columns, index_options, algorithm, using = super
+        algorithm = nil if DatabaseServer.creating_new_shard && algorithm == "CONCURRENTLY"
+        [index_name, index_type, index_columns, index_options, algorithm, using]
+      end
     end
   end
 end

data/lib/switchman/active_record/query_cache.rb

@@ -1,99 +1,125 @@
 module Switchman
   module ActiveRecord
     module QueryCache
-      # thread local accessors to replace @query_cache_enabled
-      def query_cache
-        thread_cache = Thread.current[:query_cache] ||= {}
-        thread_cache[self.object_id] ||= Hash.new { |h,sql| h[sql] = {} }
-      end
+      if ::Rails.version < '5.0.1'
+        # thread local accessors to replace @query_cache_enabled
+        def query_cache
+          thread_cache = Thread.current[:query_cache] ||= {}
+          thread_cache[self.object_id] ||= Hash.new { |h,sql| h[sql] = {} }
+        end
 
-      def query_cache_enabled
-        Thread.current[:query_cache_enabled]
-      end
+        def query_cache_enabled
+          Thread.current[:query_cache_enabled]
+        end
 
-      def query_cache_enabled=(value)
-        Thread.current[:query_cache_enabled] = value
-      end
+        def query_cache_enabled=(value)
+          Thread.current[:query_cache_enabled] = value
+        end
 
-      # basically wholesale repeat of the methods from the original (see
-      # https://github.com/rails/rails/blob/master/activerecord/lib/active_record/connection_adapters/abstract/query_cache.rb),
-      # but with self.query_cache_enabled and self.query_cache_enabled= instead
-      # of @query_cache_enabled.
+        # basically wholesale repeat of the methods from the original (see
+        # https://github.com/rails/rails/blob/master/activerecord/lib/active_record/connection_adapters/abstract/query_cache.rb),
+        # but with self.query_cache_enabled and self.query_cache_enabled= instead
+        # of @query_cache_enabled.
 
-      def enable_query_cache!
-        self.query_cache_enabled = true
-      end
+        def enable_query_cache!
+          self.query_cache_enabled = true
+        end
 
-      def disable_query_cache!
-        self.query_cache_enabled = false
-      end
+        def disable_query_cache!
+          self.query_cache_enabled = false
+        end
 
-      def cache
-        old, self.query_cache_enabled = query_cache_enabled, true
-        yield
-      ensure
-        self.query_cache_enabled = old
-        clear_query_cache unless self.query_cache_enabled
-      end
+        def cache
+          old, self.query_cache_enabled = query_cache_enabled, true
+          yield
+        ensure
+          self.query_cache_enabled = old
+          clear_query_cache unless self.query_cache_enabled
+        end
 
-      def uncached
-        old, self.query_cache_enabled = query_cache_enabled, false
-        yield
-      ensure
-        self.query_cache_enabled = old
-      end
+        def uncached
+          old, self.query_cache_enabled = query_cache_enabled, false
+          yield
+        ensure
+          self.query_cache_enabled = old
+        end
 
-      def clear_query_cache
-        Thread.current[:query_cache].try(:clear)
-      end
+        def clear_query_cache
+          Thread.current[:query_cache]&.clear
+        end
 
-      def select_all(arel, name = nil, binds = [], preparable: nil)
-        if self.query_cache_enabled && !locked?(arel)
-          arel, binds = binds_from_relation(arel, binds)
-          sql = to_sql(arel, binds)
-          if ::Rails.version >= '5'
-            cache_sql(sql, binds) { super(sql, name, binds, preparable: preparable) }
-          else
-            cache_sql(sql, binds) { super(sql, name, binds) }
-          end
-        else
-          if ::Rails.version >= '5'
-            super
+        def select_all(arel, name = nil, binds = [], preparable: nil)
+          if self.query_cache_enabled && !locked?(arel)
+            arel, binds = binds_from_relation(arel, binds)
+            sql = to_sql(arel, binds)
+            if ::Rails.version >= '5'
+              cache_sql(sql, binds) { super(sql, name, binds, preparable: preparable) }
+            else
+              cache_sql(sql, binds) { super(sql, name, binds) }
+            end
           else
-            super(arel, name, binds)
+            if ::Rails.version >= '5'
+              super
+            else
+              super(arel, name, binds)
+            end
           end
         end
-      end
 
-      # no reason to define these on the including class directly. the super
-      # works just as well from a method on the included module
-      [:insert, :update, :delete].each do |method_name|
-        class_eval <<-end_code, __FILE__, __LINE__ + 1
-          def #{method_name}(*args)
-            clear_query_cache if self.query_cache_enabled
-            super
-          end
-        end_code
+        # no reason to define these on the including class directly. the super
+        # works just as well from a method on the included module
+        [:insert, :update, :delete].each do |method_name|
+          class_eval <<-end_code, __FILE__, __LINE__ + 1
+            def #{method_name}(*args)
+              clear_query_cache if self.query_cache_enabled
+              super
+            end
+          end_code
+        end
       end
 
       private
 
-      def cache_sql(sql, binds)
-        # have to include the shard id in the cache key because of switching dbs on the same connection
-        sql = "#{self.shard.id}::#{sql}"
-        result =
-            if query_cache[sql].key?(binds)
-              ::ActiveSupport::Notifications.instrument("sql.active_record",
-                                                      :sql => sql, :binds => binds, :name => "CACHE", :connection_id => object_id)
-              query_cache[sql][binds]
-            else
-              query_cache[sql][binds] = yield
-            end
+      if ::Rails.version < '5.1'
+        def cache_sql(sql, binds)
+          # have to include the shard id in the cache key because of switching dbs on the same connection
+          sql = "#{self.shard.id}::#{sql}"
+          result =
+              if query_cache[sql].key?(binds)
+                ::ActiveSupport::Notifications.instrument("sql.active_record",
+                                                        :sql => sql, :binds => binds, :name => "CACHE", :connection_id => object_id)
+                query_cache[sql][binds]
+              else
+                query_cache[sql][binds] = yield
+              end
 
-        if ::ActiveRecord::Result === result
-          result.dup
-        else
-          result.collect { |row| row.dup }
+          if ::ActiveRecord::Result === result
+            result.dup
+          else
+            result.collect { |row| row.dup }
+          end
+        end
+      else
+        def cache_sql(sql, name, binds)
+          # have to include the shard id in the cache key because of switching dbs on the same connection
+          sql = "#{self.shard.id}::#{sql}"
+          @lock.synchronize do
+            result =
+                if query_cache[sql].key?(binds)
+                  ::ActiveSupport::Notifications.instrument(
+                      "sql.active_record",
+                      sql: sql,
+                      binds: binds,
+                      name: name,
+                      connection_id: object_id,
+                      cached: true,
+                  )
+                  query_cache[sql][binds]
+                else
+                  query_cache[sql][binds] = yield
+                end
+            result.dup
+          end
         end
       end
     end

data/lib/switchman/active_record/query_methods.rb

@@ -19,11 +19,11 @@ module Switchman
         @values[:shard_source]
       end
       def shard_value=(value)
-        raise ImmutableRelation if @loaded
+        raise ::ActiveRecord::ImmutableRelation if @loaded
         @values[:shard] = value
       end
       def shard_source_value=(value)
-        raise ImmutableRelation if @loaded
+        raise ::ActiveRecord::ImmutableRelation if @loaded
         @values[:shard_source] = value
       end
 
@@ -126,11 +126,18 @@ module Switchman
           def transpose_#{type}_clauses(source_shard, target_shard, remove_nonlocal_primary_keys)
             if ::Rails.version >= '5'
               unless (predicates = #{type}_clause.send(:predicates)).empty?
-                new_predicates = transpose_predicates(predicates, source_shard,
-                                                      target_shard, remove_nonlocal_primary_keys)
-                if new_predicates != predicates
+                new_predicates, new_binds = transpose_predicates(predicates, source_shard,
+                                                                 target_shard, remove_nonlocal_primary_keys,
+                                                                 binds: #{type}_clause.binds,
+                                                                 dup_binds_on_mutation: true)
+                if new_predicates != predicates || !new_binds.equal?(#{type}_clause.binds)
                   self.#{type}_clause = #{type}_clause.dup
-                  #{type}_clause.instance_variable_set(:@predicates, new_predicates)
+                  if new_predicates != predicates
+                    #{type}_clause.instance_variable_set(:@predicates, new_predicates)
+                  end
+                  if !new_binds.equal?(#{type}_clause.binds)
+                    #{type}_clause.instance_variable_set(:@binds, new_binds)
+                  end
                 end
               end
             else
@@ -149,6 +156,8 @@ module Switchman
       end
 
       def infer_shards_from_primary_key(predicates, binds = nil)
+        return unless klass.integral_id?
+
         primary_key = predicates.detect do |predicate|
           predicate.is_a?(::Arel::Nodes::Binary) && predicate.left.is_a?(::Arel::Attributes::Attribute) &&
             predicate.left.relation.is_a?(::Arel::Table) && predicate.left.relation.model == klass &&
@@ -181,15 +190,14 @@ module Switchman
           when ::Arel::Nodes::BindParam
             # look for a bind param with a matching column name
             if ::Rails.version >= "5"
-              binds ||= where_clause.binds + having_clause.binds
-              if binds && bind = binds.detect{|b| b.try(:name).to_s == klass.primary_key.to_s}
+              if binds && bind = binds.detect{|b| b&.name.to_s == klass.primary_key.to_s}
                 unless bind.value.is_a?(::ActiveRecord::StatementCache::Substitute)
                   local_id, id_shard = Shard.local_id_for(bind.value)
                   id_shard ||= Shard.current(klass.shard_category) if local_id
                 end
               end
             else
-              if bind_values && idx = bind_values.find_index{|b| b.is_a?(Array) && b.first.try(:name).to_s == klass.primary_key.to_s}
+              if bind_values && idx = bind_values.find_index{|b| b.is_a?(Array) && b.first&.name.to_s == klass.primary_key.to_s}
                 column, value = bind_values[idx]
                 unless value.is_a?(::ActiveRecord::StatementCache::Substitute)
                   local_id, id_shard = Shard.local_id_for(value)
@@ -268,8 +276,13 @@ module Switchman
 
       # semi-private
       public
-      def transpose_predicates(predicates, source_shard, target_shard, remove_nonlocal_primary_keys = false, binds = nil)
-        predicates.map do |predicate|
+      def transpose_predicates(predicates,
+                               source_shard,
+                               target_shard,
+                               remove_nonlocal_primary_keys = false,
+                               binds: nil,
+                               dup_binds_on_mutation: false)
+        result = predicates.map do |predicate|
           next predicate unless predicate.is_a?(::Arel::Nodes::Binary)
           next predicate unless predicate.left.is_a?(::Arel::Attributes::Attribute)
           relation, column = relation_and_column(predicate.left)
@@ -312,8 +325,13 @@ module Switchman
           when ::Arel::Nodes::BindParam
             # look for a bind param with a matching column name
             if ::Rails.version >= "5"
-              binds ||= where_clause.binds + having_clause.binds
-              if binds && bind = binds.detect{|b| b.try(:name).to_s == predicate.left.name.to_s}
+              if binds && bind = binds.detect{|b| b&.name.to_s == predicate.left.name.to_s}
+                # before we mutate, dup
+                if dup_binds_on_mutation
+                  binds = binds.map(&:dup)
+                  dup_binds_on_mutation = false
+                  bind = binds.find { |b| b&.name.to_s == predicate.left.name.to_s }
+                end
                 if bind.value.is_a?(::ActiveRecord::StatementCache::Substitute)
                   bind.value.sharded = true # mark for transposition later
                   bind.value.primary = true if type == :primary
@@ -325,7 +343,7 @@ module Switchman
                 end
               end
             else
-              if bind_values && idx = bind_values.find_index{|b| b.is_a?(Array) && b.first.try(:name).to_s == predicate.left.name.to_s}
+              if bind_values && idx = bind_values.find_index{|b| b.is_a?(Array) && b.first&.name.to_s == predicate.left.name.to_s}
                 column, value = bind_values[idx]
                 if value.is_a?(::ActiveRecord::StatementCache::Substitute)
                   value.sharded = true # mark for transposition later
@@ -356,6 +374,8 @@ module Switchman
             predicate.class.new(predicate.left, new_right_value)
           end
         end
+        result = [result, binds] if ::Rails.version >= '5'
+        result
       end
     end
   end

data/lib/switchman/active_record/statement_cache.rb

@@ -44,12 +44,22 @@ module Switchman
         end
       end
 
-      def generic_query_builder(connection)
-        @query_builder ||= connection.cacheable_query(@arel)
-      end
+      if ::Rails.version < '5.1'
+        def generic_query_builder(connection)
+          @query_builder ||= connection.cacheable_query(@arel)
+        end
+
+        def qualified_query_builder(shard, klass)
+          @qualified_query_builders[shard.id] ||= klass.connection.cacheable_query(@arel)
+        end
+      else
+        def generic_query_builder(connection)
+          @query_builder ||= connection.cacheable_query(self.class, @arel)
+        end
 
-      def qualified_query_builder(shard, klass)
-        @qualified_query_builders[shard.id] ||= klass.connection.cacheable_query(@arel)
+        def qualified_query_builder(shard, klass)
+          @qualified_query_builders[shard.id] ||= klass.connection.cacheable_query(self.class, @arel)
+        end
       end
 
       module BindMap

data/lib/switchman/active_record/where_clause_factory.rb

@@ -21,7 +21,7 @@ module Switchman
           where_clause = super
           predicates = where_clause.send(:predicates)
           @scope.send(:infer_shards_from_primary_key, predicates, where_clause.binds) if @scope.shard_source_value == :implicit && @scope.shard_value.is_a?(Shard)
-          predicates = @scope.transpose_predicates(predicates, nil, @scope.primary_shard, false, where_clause.binds)
+          predicates, _new_binds = @scope.transpose_predicates(predicates, nil, @scope.primary_shard, false, binds: where_clause.binds)
           where_clause.instance_variable_set(:@predicates, predicates)
           where_clause
         else

data/lib/switchman/call_super.rb

@@ -1,14 +1,13 @@
 module Switchman
   module CallSuper
     def super_method_above(method_name, above_module)
-      @super_methods ||= {}
-      @super_methods[[method_name, above_module]] ||= begin
-        method = method(method_name)
-        while method.owner != above_module
-          method = method.super_method
-        end
-        method.super_method
+      method = method(method_name)
+      last_owner = method.owner
+      while method.owner != above_module
+        method = method.super_method
+        raise "Could not find super method ``#{method_name}' for #{self.class}" if method.owner == last_owner
       end
+      method.super_method
     end
 
     def call_super(method, above_module, *args, &block)

data/lib/switchman/connection_pool_proxy.rb

@@ -10,7 +10,7 @@ module Switchman
   end
 
   class ConnectionPoolProxy
-    delegate :spec, :connected?, :default_schema, :with_connection,
+    delegate :spec, :connected?, :default_schema, :with_connection, :query_cache_enabled, :active_connection?,
              :to => :current_pool
 
     attr_reader :category, :schema_cache
@@ -71,7 +71,12 @@ module Switchman
       end
     end
 
-    %w{release_connection disconnect! clear_reloadable_connections! verify_active_connections! clear_stale_cached_connections!}.each do |method|
+    %w{release_connection disconnect!
+       clear_reloadable_connections!
+       verify_active_connections!
+       clear_stale_cached_connections!
+       enable_query_cache!
+       disable_query_cache! }.each do |method|
       class_eval(<<-EOS)
           def #{method}
             @connection_pools.values.each(&:#{method})
@@ -126,6 +131,9 @@ module Switchman
 
       ::ActiveRecord::ConnectionAdapters::ConnectionPool.new(spec).tap do |pool|
         pool.shard = shard
+        if ::Rails.version >= '5.0.1'
+          pool.enable_query_cache! if !@connection_pools.empty? && @connection_pools.first.last.query_cache_enabled
+        end
       end
     end
   end

data/lib/switchman/database_server.rb

@@ -3,6 +3,8 @@ module Switchman
     attr_accessor :id
 
     class << self
+      attr_accessor :creating_new_shard
+
       def all
         database_servers.values
       end
@@ -134,7 +136,7 @@ module Switchman
       create_schema = options[:schema]
       # look for another shard associated with this db
       other_shard = self.shards.where("name<>':memory:' OR name IS NULL").order(:id).first
-      temp_name = other_shard.try(:name) unless id == ::Rails.env
+      temp_name = other_shard&.name unless id == ::Rails.env
       temp_name = Shard.default.name if id == ::Rails.env
 
       case config[:adapter]
@@ -158,7 +160,7 @@ module Switchman
           create_statement = lambda { "CREATE DATABASE #{name}" }
       end
       sharding_config = Switchman.config
-      config_create_statement = sharding_config[config[:adapter]].try(:[], :create_statement)
+      config_create_statement = sharding_config[config[:adapter]]&.[](:create_statement)
       config_create_statement ||= sharding_config[:create_statement]
       if config_create_statement
         create_commands = Array(config_create_statement).dup
@@ -173,6 +175,7 @@ module Switchman
           shard.id = options[:id] if options[:id]
         end
         begin
+          self.class.creating_new_shard = true
           if name.nil?
             base_name = self.config[:database] % self.config
             base_name = $1 if base_name =~ /(?:.*\/)(.+)_shard_\d+(?:\.sqlite3)?$/
@@ -233,6 +236,8 @@ module Switchman
           shard.drop_database if shard.name == name rescue nil
           reset_column_information unless create_schema == false rescue nil
           raise
+        ensure
+          self.class.creating_new_shard = false
         end
       end
 

data/lib/switchman/engine.rb

@@ -2,7 +2,7 @@ module Switchman
   class Engine < ::Rails::Engine
     isolate_namespace Switchman
 
-    config.autoload_once_paths << File.expand_path(File.join(__FILE__, "../../../app/models"))
+    config.autoload_once_paths << File.expand_path("app/models", config.paths.path)
 
     def self.lookup_stores(cache_store_config)
       result = {}
@@ -72,6 +72,7 @@ module Switchman
         require "switchman/active_record/connection_pool"
         require "switchman/active_record/finder_methods"
         require "switchman/active_record/log_subscriber"
+        require "switchman/active_record/migration"
         require "switchman/active_record/model_schema"
         require "switchman/active_record/persistence"
         require "switchman/active_record/predicate_builder"
@@ -87,7 +88,7 @@ module Switchman
         require "switchman/call_super"
         require "switchman/rails"
         require "switchman/shackles/relation"
-        require "switchman/shard_internal"
+        require_dependency "switchman/shard_internal"
         require "switchman/standard_error"
 
         ::StandardError.include(StandardError)
@@ -124,9 +125,15 @@ module Switchman
         # we want it to find the definition from
         # ActiveRecord::ConnectionAdapters::DatabaseStatements, not
         # ActiveRecord::ConnectionAdapters::QueryCache
-        ::ActiveRecord::ConnectionAdapters::QueryCache.send(:remove_method, :select_all)
+        ::ActiveRecord::ConnectionAdapters::QueryCache.send(:remove_method, :select_all) if ::Rails.version < '5.0.1'
 
         ::ActiveRecord::LogSubscriber.prepend(ActiveRecord::LogSubscriber)
+        ::ActiveRecord::Migration.prepend(ActiveRecord::Migration)
+        if ::Rails.version >= '5'
+          ::ActiveRecord::Migration::Compatibility::V5_0.prepend(ActiveRecord::Migration::Compatibility::V5_0)
+        end
+        ::ActiveRecord::Migrator.prepend(ActiveRecord::Migrator)
+
         ::ActiveRecord::Reflection::AbstractReflection.include(ActiveRecord::Reflection::AbstractReflection)
         ::ActiveRecord::Reflection::AssociationReflection.prepend(ActiveRecord::Reflection::AssociationScopeCache)
         ::ActiveRecord::Reflection::ThroughReflection.prepend(ActiveRecord::Reflection::AssociationScopeCache)

data/lib/switchman/r_spec_helper.rb

@@ -118,7 +118,8 @@ module Switchman
       klass.before do
         raise "Sharding did not set up correctly" if @@sharding_failed
         Shard.clear_cache
-        if use_transactional_fixtures
+        if ::Rails.version >= '5.1' ? use_transactional_tests :
+          (::Rails.version >= '5' && use_transactional_tests) || use_transactional_fixtures
           Shard.default(true)
           @shard1 = Shard.find(@shard1.id)
           @shard2 = Shard.find(@shard2.id)
@@ -134,7 +135,8 @@ module Switchman
 
       klass.after do
         next if @@sharding_failed
-        if use_transactional_fixtures
+        if ::Rails.version >= '5.1' ? use_transactional_tests :
+           (::Rails.version >= '5' && use_transactional_tests) || use_transactional_fixtures
           shards = [@shard2]
           shards << @shard1 unless @shard1.database_server == Shard.default.database_server
           shards.each do |shard|

data/lib/switchman/sharded_instrumenter.rb

@@ -6,7 +6,7 @@ module Switchman
     end
 
     def instrument(name, payload={})
-      shard = @shard_host.try(:shard)
+      shard = @shard_host&.shard
       # attribute_methods_generated? will be false during a reload -
       # when we might be doing a query while defining attribute methods,
       # so just avoid logging then

data/lib/switchman/version.rb

@@ -1,3 +1,3 @@
 module Switchman
-  VERSION = "1.9.0"
+  VERSION = "1.10.0"
 end

data/lib/tasks/switchman.rake

@@ -60,21 +60,23 @@ module Switchman
         end
 
         ::Shackles.activate(:deploy) do
-          begin
-            categories = categories.call if categories.respond_to?(:call)
-            Shard.with_each_shard(scope, categories, options) do
-              shard = Shard.current
-              puts "#{shard.id}: #{shard.description}"
-              ::ActiveRecord::Base.connection_pool.spec.config[:shard_name] = Shard.current.name
-              ::ActiveRecord::Base.configurations[::Rails.env] = ::ActiveRecord::Base.connection_pool.spec.config.stringify_keys
-              shard.database_server.unshackle do
-                old_actions.each { |action| action.call(*task_args) }
+          Shard.default.database_server.unshackle do
+            begin
+              categories = categories.call if categories.respond_to?(:call)
+              Shard.with_each_shard(scope, categories, options) do
+                shard = Shard.current
+                puts "#{shard.id}: #{shard.description}"
+                ::ActiveRecord::Base.connection_pool.spec.config[:shard_name] = Shard.current.name
+                ::ActiveRecord::Base.configurations[::Rails.env] = ::ActiveRecord::Base.connection_pool.spec.config.stringify_keys
+                shard.database_server.unshackle do
+                  old_actions.each { |action| action.call(*task_args) }
+                end
+                nil
               end
-              nil
+            rescue => e
+              puts "Exception from #{e.current_shard.id}: #{e.current_shard.description}" if options[:parallel] != 0
+              raise
             end
-          rescue => e
-            puts "Exception from #{e.current_shard.id}: #{e.current_shard.description}" if options[:parallel] != 0
-            raise
           end
         end
       end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: switchman
 version: !ruby/object:Gem::Version
-  version: 1.9.0
+  version: 1.10.0
 platform: ruby
 authors:
 - Cody Cutrer
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-12-08 00:00:00.000000000 Z
+date: 2017-06-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: railties
@@ -19,9 +19,9 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '4.2'
-    - - "<="
+    - - "<"
       - !ruby/object:Gem::Version
-        version: '5.1'
+        version: '5.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -29,9 +29,9 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '4.2'
-    - - "<="
+    - - "<"
       - !ruby/object:Gem::Version
-        version: '5.1'
+        version: '5.2'
 - !ruby/object:Gem::Dependency
   name: activerecord
   requirement: !ruby/object:Gem::Requirement
@@ -39,9 +39,9 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '4.2'
-    - - "<="
+    - - "<"
       - !ruby/object:Gem::Version
-        version: '5.1'
+        version: '5.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -49,23 +49,23 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '4.2'
-    - - "<="
+    - - "<"
       - !ruby/object:Gem::Version
-        version: '5.1'
+        version: '5.2'
 - !ruby/object:Gem::Dependency
   name: shackles
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.3.0
+        version: '1.3'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.3.0
+        version: '1.3'
 - !ruby/object:Gem::Dependency
   name: open4
   requirement: !ruby/object:Gem::Requirement
@@ -86,14 +86,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.1.0
+        version: '2.1'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.1.0
+        version: '2.1'
 - !ruby/object:Gem::Dependency
   name: byebug
   requirement: !ruby/object:Gem::Requirement
@@ -108,20 +108,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: mysql2
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.3'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.3'
 - !ruby/object:Gem::Dependency
   name: pg
   requirement: !ruby/object:Gem::Requirement
@@ -142,14 +128,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 3.1.0
+        version: 3.5.2
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 3.1.0
+        version: 3.5.2
 - !ruby/object:Gem::Dependency
   name: sqlite3
   requirement: !ruby/object:Gem::Requirement
@@ -170,14 +156,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '11.3'
+        version: '12.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '11.3'
+        version: '12.0'
 description: Sharding
 email:
 - cody@instructure.com
@@ -203,6 +189,7 @@ files:
 - lib/switchman/active_record/connection_pool.rb
 - lib/switchman/active_record/finder_methods.rb
 - lib/switchman/active_record/log_subscriber.rb
+- lib/switchman/active_record/migration.rb
 - lib/switchman/active_record/model_schema.rb
 - lib/switchman/active_record/persistence.rb
 - lib/switchman/active_record/postgresql_adapter.rb
@@ -256,7 +243,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.2
+rubygems_version: 2.6.11
 signing_key: 
 specification_version: 4
 summary: Rails 4 sharding magic