switchman 1.10.4 → 1.11.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA256:
-  metadata.gz: ec38b2f9f4514dd6e8a395c91d56ec88e110df9f65901b09e9990de84d7b5144
-  data.tar.gz: 8b1941a4f918b184917a0f4293b67a0f10a3317187eb98fa6736693201801a9b
+SHA1:
+  metadata.gz: 67d816fd26624b395d3ff11e802340dedeac19af
+  data.tar.gz: 4775afc373abd08b450b2af8ac3c150e4c786676
 SHA512:
-  metadata.gz: 54771d8a12ce199e67802b8be9c195b00ed8203a602027b6d0ab8776042341ad6ccf40f33c0cf0ac644c1339bcde9fe6668f442e0a864763f28be0ab8d5ba62d
-  data.tar.gz: 53e9832319bd99cdbe0032a6c66c0749f57e9c08e09df5bd7239b872d1a4a29b868603a43d13e7d6f23c6157a14fb7a75650b90c13b7f18e424c3e5e98ad54ac
+  metadata.gz: ce07a665d16609b09ac3c4bd7f8e12d7ade79b1bebf4b12cfb98c4da70f7851b3229e9f65fb12b716b917e9ac24ecab48dd4e289ca69beacd723ddb39e21e81a
+  data.tar.gz: 25ed4aafe75a02fdcc9db632ececb598a73778219ac957c255c21ee5aa0e1606a69c7e04f1528a3e67acdee89046b99123ce17e13a6cf5735b003352e21a4209

data/lib/switchman/active_record/association.rb

@@ -69,27 +69,17 @@ module Switchman
       end
     end
 
-    if ::Rails.version >= '5'
-      module Extension
-        def self.build(_model, _reflection)
-        end
-
-        def self.valid_options
-          [:multishard]
-        end
+    module Extension
+      def self.build(_model, _reflection)
       end
 
-      ::ActiveRecord::Associations::Builder::Association.extensions << Extension
-    else
-      module Builder
-        module CollectionAssociation
-          def valid_options
-            super + [:multishard]
-          end
-        end
+      def self.valid_options
+        [:multishard]
       end
     end
 
+    ::ActiveRecord::Associations::Builder::Association.extensions << Extension
+
     module Preloader
       module Association
         def associated_records_by_owner(preloader = nil)

data/lib/switchman/active_record/base.rb

@@ -4,14 +4,8 @@ module Switchman
       module ClassMethods
         delegate :shard, to: :all
 
-        if ::Rails.version < '5'
-          def shard_category
-            @shard_category || (self.superclass < ::ActiveRecord::Base && self.superclass.shard_category) || :primary
-          end
-        else
-          def shard_category
-            connection_specification_name.to_sym
-          end
+        def shard_category
+          connection_specification_name.to_sym
         end
 
         def shard_category=(category)
@@ -22,13 +16,7 @@ module Switchman
           end
           categories[category] ||= []
           categories[category] << self
-          if ::Rails.version < '5'
-            connection_handler.uninitialize_ar(self)
-            @shard_category = category
-            connection_handler.initialize_categories(superclass)
-          else
-            self.connection_specification_name = category.to_s
-          end
+          self.connection_specification_name = category.to_s
         end
 
         def integral_id?
@@ -104,22 +92,18 @@ module Switchman
         end
       end
 
-      def scope_class
-        ::Rails.version >= '5' ? self.class : self.class.base_class
-      end
-
       def save(*args)
         @shard_set_in_stone = true
-        scope_class.shard(shard, :implicit).scoping { super }
+        self.class.shard(shard, :implicit).scoping { super }
       end
 
       def save!(*args)
         @shard_set_in_stone = true
-        scope_class.shard(shard, :implicit).scoping { super }
+        self.class.shard(shard, :implicit).scoping { super }
       end
 
       def destroy
-        scope_class.shard(shard, :implicit).scoping { super }
+        self.class.shard(shard, :implicit).scoping { super }
       end
 
       def clone
@@ -152,12 +136,10 @@ module Switchman
         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
+      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

data/lib/switchman/active_record/calculations.rb

@@ -159,7 +159,7 @@ module Switchman
               'count', opts[:distinct]).as('count')
         end
 
-        haves = ::Rails.version >= "5" ? having_clause.send(:predicates) : having_values
+        haves = having_clause.send(:predicates)
         select_values += select_values unless haves.empty?
         select_values.concat opts[:group_fields].zip(opts[:group_aliases]).map { |field,aliaz|
           if field.respond_to?(:as)

data/lib/switchman/active_record/connection_handler.rb

@@ -22,9 +22,8 @@ module Switchman
         end
       end
 
-      def establish_connection(*args)
+      def establish_connection(spec)
         pool = super
-        owner, spec = ::Rails.version < '5' ? args : [nil, args.first]
 
         # this is the first place that the adapter would have been required; but now we
         # need this addition ASAP since it will be called when loading the default shard below
@@ -53,16 +52,11 @@ module Switchman
 
         @shard_connection_pools ||= { [:master, Shard.default.database_server.shareable? ? ::Rails.env : Shard.default] => pool}
 
-        category = ::Rails.version < '5' ? owner.shard_category : pool.spec.name.to_sym
+        category = pool.spec.name.to_sym
         proxy = ConnectionPoolProxy.new(category,
                                         pool,
                                         @shard_connection_pools)
-        if ::Rails.version < '5'
-          owner_to_pool[owner.name] = proxy
-          class_to_pool.clear
-        else
-          owner_to_pool[pool.spec.name] = proxy
-        end
+        owner_to_pool[pool.spec.name] = proxy
 
         if first_time
           if Shard.default.database_server.config[:prefer_slave]
@@ -107,96 +101,46 @@ module Switchman
         proxy
       end
 
-      if ::Rails.version < '5'
-        def remove_connection(model)
-          uninitialize_ar(model) if owner_to_pool[model.name].is_a?(ConnectionPoolProxy)
-          result = super
-          initialize_categories
-          result
-        end
+      def remove_connection(spec_name)
+        pool = owner_to_pool[spec_name]
+        owner_to_pool[spec_name] = pool.default_pool if pool.is_a?(ConnectionPoolProxy)
+        super
+      end
 
-        def pool_for(owner)
-          # copypasted from AR#ConnectionHandler other than proxy handling
-
-          owner_to_pool.fetch(owner.name) {
-            if ancestor_pool = pool_from_any_process_for(owner)
-              # 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.
-              if ancestor_pool.is_a?(ConnectionPoolProxy)
-                establish_connection owner, ancestor_pool.default_pool.spec
-              else
-                establish_connection owner, ancestor_pool.spec
-              end
+      def retrieve_connection_pool(spec_name)
+        owner_to_pool.fetch(spec_name) do
+          if ancestor_pool = pool_from_any_process_for(spec_name)
+            # 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.
+            spec = if ancestor_pool.is_a?(ConnectionPoolProxy)
+              ancestor_pool.default_pool.spec
             else
-              owner_to_pool[owner.name] = nil
-            end
-          }
-        end
-
-        def retrieve_connection_pool(klass)
-          class_to_pool[klass.name] ||= begin
-            original_klass = klass
-            until pool = pool_for(klass)
-              klass = klass.superclass
-              break unless klass <= Base
-            end
-
-            if pool.is_a?(ConnectionPoolProxy) && pool.category != original_klass.shard_category
-              default_pool = pool.default_pool
-              pool = nil
-              class_to_pool.each_value { |p| pool = p if p.is_a?(ConnectionPoolProxy) &&
-                  p.category == original_klass.shard_category &&
-                  p.default_pool == default_pool }
-              pool ||= ConnectionPoolProxy.new(original_klass.shard_category, default_pool, @shard_connection_pools)
+              ancestor_pool.spec
             end
-
-            class_to_pool[original_klass.name] = pool
-          end
-        end
-      else
-        def remove_connection(spec_name)
-          pool = owner_to_pool[spec_name]
-          owner_to_pool[spec_name] = pool.default_pool if pool.is_a?(ConnectionPoolProxy)
-          super
-        end
-
-        def retrieve_connection_pool(spec_name)
-          owner_to_pool.fetch(spec_name) do
-            if ancestor_pool = pool_from_any_process_for(spec_name)
-              # 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.
-              spec = if ancestor_pool.is_a?(ConnectionPoolProxy)
-                ancestor_pool.default_pool.spec
-              else
-                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"
-              primary_pool = retrieve_connection_pool("primary")
-              if primary_pool.is_a?(ConnectionPoolProxy)
-                ConnectionPoolProxy.new(spec_name.to_sym, primary_pool.default_pool, @shard_connection_pools)
-              else
-                primary_pool
-              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"
+            primary_pool = retrieve_connection_pool("primary")
+            if primary_pool.is_a?(ConnectionPoolProxy)
+              ConnectionPoolProxy.new(spec_name.to_sym, primary_pool.default_pool, @shard_connection_pools)
             else
-              owner_to_pool[spec_name] = nil
+              primary_pool
             end
+          else
+            owner_to_pool[spec_name] = nil
           end
         end
       end
 
       def clear_idle_connections!(since_when)
-        # TODO in rails 4.2+ s/connection_pools.values/connection_pool_list/
-        connection_pools.values.each{ |pool| pool.clear_idle_connections!(since_when) }
+        connection_pool_list.each{ |pool| pool.clear_idle_connections!(since_when) }
       end
 
       def switchman_connection_pool_proxies
-        (::Rails.version < '5' ? class_to_pool : owner_to_pool).values.uniq.select{|p| p.is_a?(ConnectionPoolProxy)}
+        owner_to_pool.values.uniq.select{|p| p.is_a?(ConnectionPoolProxy)}
       end
 
       private

data/lib/switchman/active_record/connection_pool.rb

@@ -39,12 +39,7 @@ module Switchman
         conn
       end
 
-      def release_connection(with_id = nil)
-        with_id ||= if ::Rails.version >= '5'
-                      Thread.current
-                    else
-                      current_connection_id
-                    end
+      def release_connection(with_id = Thread.current)
         super(with_id)
 
         if spec.config[:idle_timeout]

data/lib/switchman/active_record/finder_methods.rb

@@ -58,7 +58,7 @@ module Switchman
         end
 
         relation.activate do |shard_rel|
-          return true if connection.select_value(shard_rel, "#{name} Exists", shard_rel.bind_values)
+          return true if connection.select_value(shard_rel, "#{name} Exists", shard_rel.bound_attributes)
         end
         false
       end

data/lib/switchman/active_record/log_subscriber.rb

@@ -17,11 +17,7 @@ module Switchman
         shard = "  [#{shard[:database_server_id]}:#{shard[:id]} #{shard[:env]}]" if shard
 
         unless (payload[:binds] || []).empty?
-          if ::Rails.version < '5'
-            binds = "  " + payload[:binds].map { |col,v|
-              render_bind(col, v)
-            }.inspect
-          elsif ::Rails.version < '5.0.3'
+          if ::Rails.version < '5.0.3'
             binds = "  " + payload[:binds].map { |attr| render_bind(attr) }.inspect
           else
             casted_params = type_casted_binds(payload[:binds], payload[:type_casted_binds])
@@ -31,17 +27,8 @@ module Switchman
           end
         end
 
-        if ::Rails.version >= '5'
-          name = colorize_payload_name(name, payload[:name])
-          sql  = color(sql, sql_color(sql), true)
-        else
-          if odd?
-            name = color(name, self.class::CYAN, true)
-            sql  = color(sql, nil, true)
-          else
-            name = color(name, self.class::MAGENTA, true)
-          end
-        end
+        name = colorize_payload_name(name, payload[:name])
+        sql  = color(sql, sql_color(sql), true)
 
         debug "  #{name}  #{sql}#{binds}#{shard}"
       end

data/lib/switchman/active_record/postgresql_adapter.rb

@@ -1,12 +1,6 @@
 module Switchman
   module ActiveRecord
     module PostgreSQLAdapter
-      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
       def create_database(name, options = {})
         options = { encoding: 'utf8' }.merge!(options.symbolize_keys)
@@ -58,9 +52,16 @@ module Switchman
         SQL
       end
 
-      method_name = ::Rails.version >= '5' ? :data_source_exists? : :table_exists?
-      class_eval <<-RUBY, __FILE__, __LINE__ + 1
-        def #{method_name}(name)
+      if ::Rails.version >= '5.1'
+        def extract_schema_qualified_name(string)
+          name = ::ActiveRecord::ConnectionAdapters::PostgreSQL::Utils.extract_schema_qualified_name(string.to_s)
+          if string && !name.schema && use_qualified_names?
+            name.instance_variable_set(:@schema, shard.name)
+          end
+          [name.schema, name.identifier]
+        end
+      else
+        def data_source_exists?(name)
           name = ::ActiveRecord::ConnectionAdapters::PostgreSQL::Utils.extract_schema_qualified_name(name.to_s)
           return false unless name.identifier
           if !name.schema && use_qualified_names?
@@ -72,11 +73,11 @@ module Switchman
             FROM pg_class c
             LEFT JOIN pg_namespace n ON n.oid = c.relnamespace
             WHERE c.relkind IN ('r','v','m') -- (r)elation/table, (v)iew, (m)aterialized view
-            AND c.relname = '\#{name.identifier}'
-            AND n.nspname = \#{name.schema ? "'\#{name.schema}'" : 'ANY (current_schemas(false))'}
+            AND c.relname = '#{name.identifier}'
+            AND n.nspname = #{name.schema ? "'#{name.schema}'" : 'ANY (current_schemas(false))'}
           SQL
         end
-      RUBY
+      end
 
       def view_exists?(name)
         name = ::ActiveRecord::ConnectionAdapters::PostgreSQL::Utils.extract_schema_qualified_name(name.to_s)
@@ -213,28 +214,6 @@ module Switchman
         algorithm = nil if DatabaseServer.creating_new_shard && algorithm == "CONCURRENTLY"
         [index_name, index_type, index_columns, index_options, algorithm, using]
       end
-
-      def rename_table(table_name, new_name)
-        clear_cache!
-        execute "ALTER TABLE #{quote_table_name(table_name)} RENAME TO #{quote_local_table_name(new_name)}"
-        pk, seq = pk_and_sequence_for(new_name)
-        if pk
-          idx = "#{table_name}_pkey"
-          new_idx = "#{new_name}_pkey"
-          execute "ALTER INDEX #{quote_table_name(idx)} RENAME TO #{quote_local_table_name(new_idx)}"
-          if seq && seq.identifier == "#{table_name}_#{pk}_seq"
-            new_seq = "#{new_name}_#{pk}_seq"
-            execute "ALTER TABLE #{seq.quoted} RENAME TO #{quote_local_table_name(new_seq)}"
-          end
-        end
-        rename_table_indexes(table_name, new_name)
-      end
-
-      def rename_index(table_name, old_name, new_name)
-        validate_index_length!(table_name, new_name)
-
-        execute "ALTER INDEX #{quote_column_name(old_name)} RENAME TO #{quote_local_table_name(new_name)}"
-      end
     end
   end
 end

data/lib/switchman/active_record/query_cache.rb

@@ -52,17 +52,9 @@ module Switchman
           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
+            cache_sql(sql, binds) { super(sql, name, binds, preparable: preparable) }
           else
-            if ::Rails.version >= '5'
-              super
-            else
-              super(arel, name, binds)
-            end
+            super
           end
         end
 

data/lib/switchman/active_record/query_methods.rb

@@ -42,33 +42,6 @@ module Switchman
         self
       end
 
-      if ::Rails.version < '5'
-        # moved to WhereClauseFactory#build in Rails 5
-        def build_where(opts, other = [])
-          case opts
-          when String, Array
-            values = Hash === other.first ? other.first.values : other
-
-            values.grep(ActiveRecord::Relation) do |rel|
-              # serialize subqueries against the same shard as the outer query is currently
-              # targeted to run against
-              if rel.shard_source_value == :implicit && rel.primary_shard != primary_shard
-                rel.shard!(primary_shard)
-              end
-            end
-
-            [@klass.send(:sanitize_sql, other.empty? ? opts : ([opts] + other))]
-          when Hash, ::Arel::Nodes::Node
-            predicates = super
-            infer_shards_from_primary_key(predicates) if shard_source_value == :implicit && shard_value.is_a?(Shard)
-            predicates = transpose_predicates(predicates, nil, primary_shard)
-            predicates
-          else
-            super
-          end
-        end
-      end
-
       # the shard that where_values are relative to. if it's multiple shards, they're stored
       # relative to the first shard
       def primary_shard
@@ -103,49 +76,26 @@ module Switchman
         end
       end
 
-      if ::Rails.version < '5'
-        # fixes an issue in Rails 4.2 with `reverse_sql_order` and qualified names
-        # where quoted_table_name is called before shard(s) have been activated
-        # if there's no ordering
-        def reverse_order!
-          orders = order_values.uniq
-          orders.reject!(&:blank?)
-          if orders.empty?
-            self.order_values = [arel_table[primary_key].desc]
-          else
-            self.order_values = reverse_sql_order(orders)
-          end
-          self
-        end
-      end
-
       private
 
       [:where, :having].each do |type|
         class_eval <<-RUBY, __FILE__, __LINE__ + 1
-          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, 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
-                  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
+          def transpose_#{type}_clauses(source_shard, target_shard, remove_nonlocal_primary_keys)            
+            unless (predicates = #{type}_clause.send(:predicates)).empty?
+              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
+                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
-            else
-              unless #{type}_values.empty?
-                self.#{type}_values = transpose_predicates(#{type}_values,
-                  source_shard, target_shard, remove_nonlocal_primary_keys)
-              end
-            end
+            end            
           end
         RUBY
       end
@@ -189,20 +139,10 @@ module Switchman
             end
           when ::Arel::Nodes::BindParam
             # look for a bind param with a matching column name
-            if ::Rails.version >= "5"
-              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&.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)
-                  id_shard ||= Shard.current(klass.shard_category) if local_id
-                end
+            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
@@ -260,9 +200,9 @@ module Switchman
 
       def arel_columns(columns)
         columns.map do |field|
-          if (Symbol === field || String === field) && ::Rails.version >= '5' && (klass.has_attribute?(field) || klass.attribute_alias?(field)) && !from_clause.value
+          if (Symbol === field || String === field) && (klass.has_attribute?(field) || klass.attribute_alias?(field)) && !from_clause.value
             klass.arel_attribute(field, table)
-          elsif (Symbol === field || String === field) && ::Rails.version < '5' && columns_hash.key?(field.to_s) && !from_value
+          elsif (Symbol === field || String === field) && columns_hash.key?(field.to_s) && !from_value
             arel_table[field]
           elsif Symbol === field
             # the rest of this is pulled from AR - the only change is from quote_table_name to quote_column_name here
@@ -324,35 +264,21 @@ module Switchman
             local_ids
           when ::Arel::Nodes::BindParam
             # look for a bind param with a matching column name
-            if ::Rails.version >= "5"
-              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
-                else
-                  local_id = Shard.relative_id_for(bind.value, current_source_shard, target_shard)
-                  local_id = [] if remove && local_id > Shard::IDS_PER_SHARD
-                  bind.instance_variable_set(:@value, local_id)
-                  bind.instance_variable_set(:@value_for_database, nil)
-                end
+            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
-            else
-              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
-                  value.primary = true if type == :primary
-                else
-                  local_id = Shard.relative_id_for(value, current_source_shard, target_shard)
-                  local_id = [] if remove && local_id > Shard::IDS_PER_SHARD
-                  bind_values[idx] = [column, local_id]
-                end
+              if bind.value.is_a?(::ActiveRecord::StatementCache::Substitute)
+                bind.value.sharded = true # mark for transposition later
+                bind.value.primary = true if type == :primary
+              else
+                local_id = Shard.relative_id_for(bind.value, current_source_shard, target_shard)
+                local_id = [] if remove && local_id > Shard::IDS_PER_SHARD
+                bind.instance_variable_set(:@value, local_id)
+                bind.instance_variable_set(:@value_for_database, nil)
               end
             end
             predicate.right
@@ -374,7 +300,7 @@ module Switchman
             predicate.class.new(predicate.left, new_right_value)
           end
         end
-        result = [result, binds] if ::Rails.version >= '5'
+        result = [result, binds]
         result
       end
     end

data/lib/switchman/active_record/reflection.rb

@@ -12,31 +12,29 @@ module Switchman
         end
       end
 
-      if ::Rails.version >= '4.2'
-        module AssociationScopeCache
-          def initialize(*args)
-            super
-            # on ThroughReflection, these won't be initialized (cause it doesn't
-            # inherit from AssociationReflection), so make sure they're
-            # initialized here
-            @association_scope_cache ||= {}
-            @scope_lock ||= Mutex.new
-          end
+      module AssociationScopeCache
+        def initialize(*args)
+          super
+          # on ThroughReflection, these won't be initialized (cause it doesn't
+          # inherit from AssociationReflection), so make sure they're
+          # initialized here
+          @association_scope_cache ||= {}
+          @scope_lock ||= Mutex.new
+        end
 
-          # cache association scopes by shard.
-          # this technically belongs on AssociationReflection, but we put it on
-          # ThroughReflection as well, instead of delegating to its internal
-          # HasManyAssociation, losing its proper `klass`
-          def association_scope_cache(conn, owner)
-            key = conn.prepared_statements
-            if polymorphic?
-              key = [key, owner._read_attribute(@foreign_type)]
-            end
-            key = [key, shard(owner).id].flatten
-            @association_scope_cache[key] ||= @scope_lock.synchronize {
-              @association_scope_cache[key] ||= yield
-            }
+        # cache association scopes by shard.
+        # this technically belongs on AssociationReflection, but we put it on
+        # ThroughReflection as well, instead of delegating to its internal
+        # HasManyAssociation, losing its proper `klass`
+        def association_scope_cache(conn, owner)
+          key = conn.prepared_statements
+          if polymorphic?
+            key = [key, owner._read_attribute(@foreign_type)]
           end
+          key = [key, shard(owner).id].flatten
+          @association_scope_cache[key] ||= @scope_lock.synchronize {
+            @association_scope_cache[key] ||= yield
+          }
         end
       end
 

data/lib/switchman/active_record/relation.rb

@@ -46,19 +46,16 @@ module Switchman
         self.activate { |relation| relation.call_super(:explain, Relation) }
       end
 
-      to_a_method = ::Rails.version >= '5' ? :records : :to_a
-      class_eval <<-RUBY, __FILE__, __LINE__ + 1
-        def #{to_a_method}
-          return @records if loaded?
-          results = self.activate { |relation| relation.call_super(#{to_a_method.inspect}, Relation) }
-          case shard_value
-          when Array, ::ActiveRecord::Relation, ::ActiveRecord::Base
-            @records = results
-            @loaded = true
-          end
-          results
+      def records
+        return @records if loaded?
+        results = self.activate { |relation| relation.call_super(:records, Relation) }
+        case shard_value
+        when Array, ::ActiveRecord::Relation, ::ActiveRecord::Base
+          @records = results
+          @loaded = true
         end
-      RUBY
+        results
+      end
 
       %I{update_all delete_all}.each do |method|
         class_eval <<-RUBY, __FILE__, __LINE__ + 1

data/lib/switchman/active_record/statement_cache.rb

@@ -5,8 +5,7 @@ module Switchman
         def create(connection, block = Proc.new)
           relation = block.call ::ActiveRecord::StatementCache::Params.new
 
-          binds = ::Rails.version >= '5' ? relation.bound_attributes : relation.bind_values
-          bind_map = ::ActiveRecord::StatementCache::BindMap.new(binds)
+          bind_map = ::ActiveRecord::StatementCache::BindMap.new(relation.bound_attributes )
           new relation.arel, bind_map
         end
       end
@@ -65,44 +64,25 @@ module Switchman
       module BindMap
         # performs id transposition here instead of query_methods.rb
         def bind(values, current_shard, target_shard)
-          if ::Rails.version >= '5'
-            bas = @bound_attributes.dup
-            @indexes.each_with_index do |offset,i|
-              ba = bas[offset]
-              if ba.is_a?(::ActiveRecord::Relation::QueryAttribute) && ba.value.sharded
-                new_value = Shard.relative_id_for(values[i], current_shard, target_shard || current_shard)
-              else
-                new_value = values[i]
-              end
-              bas[offset] = ba.with_cast_value(new_value)
+          bas = @bound_attributes.dup
+          @indexes.each_with_index do |offset,i|
+            ba = bas[offset]
+            if ba.is_a?(::ActiveRecord::Relation::QueryAttribute) && ba.value.sharded
+              new_value = Shard.relative_id_for(values[i], current_shard, target_shard || current_shard)
+            else
+              new_value = values[i]
             end
-            bas
-          else
-            bvs = @bind_values.map { |pair| pair.dup }
-            @indexes.each_with_index do |offset,i|
-              bv = bvs[offset]
-              if bv[1].sharded
-                bv[1] = Shard.relative_id_for(values[i], current_shard, target_shard || current_shard)
-              else
-                bv[1] = values[i]
-              end
-            end
-            bvs
+            bas[offset] = ba.with_cast_value(new_value)
           end
+          bas
         end
 
         def primary_value_index
-          if ::Rails.version >= '5'
-            primary_ba_index = @bound_attributes.index do |ba|
-              ba.is_a?(::ActiveRecord::Relation::QueryAttribute) && ba.value.primary
-            end
-            if primary_ba_index
-              @indexes.index(primary_ba_index)
-            end
-          else
-            if primary_bv_index = @bind_values.index{|col, sub| sub.primary}
-              @indexes.index(primary_bv_index)
-            end
+          primary_ba_index = @bound_attributes.index do |ba|
+            ba.is_a?(::ActiveRecord::Relation::QueryAttribute) && ba.value.primary
+          end
+          if primary_ba_index
+            @indexes.index(primary_ba_index)
           end
         end
       end

data/lib/switchman/arel.rb

@@ -2,11 +2,7 @@ module Switchman
   module Arel
     module Table
       def model
-        if ::Rails.version >= '5'
-          type_caster.model
-        else
-          engine
-        end
+        type_caster.model
       end
     end
     module Visitors

data/lib/switchman/connection_pool_proxy.rb

@@ -123,7 +123,7 @@ module Switchman
         end
       end
       args = [config, "#{config[:adapter]}_connection"]
-      args.unshift(pool_key.join("/")) if ::Rails.version >= '5' # seems as good a name as any
+      args.unshift(pool_key.join("/"))
       spec = ::ActiveRecord::ConnectionAdapters::ConnectionSpecification.new(*args)
       # unfortunately the AR code that does this require logic can't really be
       # called in isolation

data/lib/switchman/database_server.rb

@@ -1,5 +1,3 @@
-require "securerandom"
-
 module Switchman
   class DatabaseServer
     attr_accessor :id
@@ -138,14 +136,27 @@ 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&.name unless id == ::Rails.env
+      temp_name = Shard.default.name if id == ::Rails.env
 
       case config[:adapter]
         when 'postgresql'
+          temp_name ||= 'public'
           create_statement = lambda { "CREATE SCHEMA #{name}" }
           password = " PASSWORD #{::ActiveRecord::Base.connection.quote(config[:password])}" if config[:password]
         when 'sqlite3'
-          # no create_statement
+          if name
+            # Try to create a db on-disk even if the only shards for sqlite are in-memory
+            temp_name = nil if temp_name == ':memory:'
+            # Put it in the db directory if there are no other sqlite shards
+            temp_name ||= 'db/dummy'
+            temp_name = File.join(File.dirname(temp_name), "#{name}.sqlite3")
+            # If they really asked for :memory:, give them :memory:
+            temp_name = name if name == ':memory:'
+            name = temp_name
+          end
         else
+          temp_name ||= self.config[:database] % self.config
           create_statement = lambda { "CREATE DATABASE #{name}" }
       end
       sharding_config = Switchman.config
@@ -159,35 +170,27 @@ module Switchman
       end
 
       create_shard = lambda do
-        shard_id = options.fetch(:id) do
-          case config[:adapter]
-            when 'postgresql'
-              id_seq = Shard.connection.quote(Shard.connection.quote_table_name('switchman_shards_id_seq'))
-              next_id = Shard.connection.select_value("SELECT nextval(#{id_seq})")
-              next_id.to_i
-            else
-              nil
-          end
-        end
-
-        if name.nil?
-          base_name = self.config[:database].to_s % self.config
-          base_name = $1 if base_name =~ /(?:.*\/)(.+)_shard_\d+(?:\.sqlite3)?$/
-          base_name = nil if base_name == ':memory:'
-          base_name << '_' if base_name
-          base_id = shard_id || SecureRandom.uuid
-          name = "#{base_name}shard_#{base_id}"
-          if config[:adapter] == 'sqlite3'
-            name = File.join('db', "#{name}.sqlite3")
-          end
+        shard = Shard.create!(:name => temp_name,
+                            :database_server => self) do |shard|
+          shard.id = options[:id] if options[:id]
         end
-
-        shard = Shard.create!(:id => shard_id,
-                              :name => name,
-                              :database_server => self)
-
         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)?$/
+            base_name = nil if base_name == ':memory:'
+            base_name << '_' if base_name
+            name = "#{base_name}shard_#{shard.id}"
+            if config[:adapter] == 'sqlite3'
+              # Try to create a db on-disk even if the only shards for sqlite are in-memory
+              temp_name = nil if temp_name == ':memory:'
+              # Put it in the db directory if there are no other sqlite shards
+              temp_name ||= 'db/dummy'
+              name = File.join(File.dirname(temp_name), "#{name}.sqlite3")
+              shard.name = name
+            end
+          end
           shard.activate(*Shard.categories) do
             ::Shackles.activate(:deploy) do
               begin
@@ -196,11 +199,14 @@ module Switchman
                     ::ActiveRecord::Base.connection.execute(stmt)
                   end
                   # have to disconnect and reconnect to the correct db
+                  shard.name = name
                   if self.shareable? && other_shard
                     other_shard.activate { ::ActiveRecord::Base.connection }
                   else
                     ::ActiveRecord::Base.connection_pool.current_pool.disconnect!
                   end
+                else
+                  shard.name = name
                 end
                 old_proc = ::ActiveRecord::Base.connection.raw_connection.set_notice_processor {} if config[:adapter] == 'postgresql'
                 old_verbose = ::ActiveRecord::Migration.verbose
@@ -223,10 +229,11 @@ module Switchman
               end
             end
           end
+          shard.save!
           shard
         rescue
           shard.destroy
-          shard.drop_database rescue nil
+          shard.drop_database if shard.name == name rescue nil
           reset_column_information unless create_schema == false rescue nil
           raise
         ensure

data/lib/switchman/engine.rb

@@ -112,9 +112,6 @@ module Switchman
         ::ActiveRecord::Associations::Association.prepend(ActiveRecord::Association)
         ::ActiveRecord::Associations::BelongsToAssociation.prepend(ActiveRecord::BelongsToAssociation)
         ::ActiveRecord::Associations::CollectionProxy.include(ActiveRecord::CollectionProxy)
-        if ::Rails.version < '5'
-          ::ActiveRecord::Associations::Builder::CollectionAssociation.include(ActiveRecord::Builder::CollectionAssociation)
-        end
 
         ::ActiveRecord::Associations::Preloader::Association.prepend(ActiveRecord::Preloader::Association)
         ::ActiveRecord::ConnectionAdapters::AbstractAdapter.prepend(ActiveRecord::AbstractAdapter)
@@ -129,9 +126,7 @@ module Switchman
 
         ::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::Migration::Compatibility::V5_0.prepend(ActiveRecord::Migration::Compatibility::V5_0)
         ::ActiveRecord::Migrator.prepend(ActiveRecord::Migrator)
 
         ::ActiveRecord::Reflection::AbstractReflection.include(ActiveRecord::Reflection::AbstractReflection)
@@ -147,12 +142,10 @@ module Switchman
         ::ActiveRecord::Relation.include(ActiveRecord::SpawnMethods)
         ::ActiveRecord::Relation.include(CallSuper)
 
-        if ::Rails.version >= '5'
-          ::ActiveRecord::Relation::WhereClauseFactory.prepend(ActiveRecord::WhereClauseFactory)
-          ::ActiveRecord::PredicateBuilder::AssociationQueryValue.prepend(ActiveRecord::PredicateBuilder::AssociationQueryValue)
-          ::ActiveRecord::TypeCaster::Map.include(ActiveRecord::TypeCaster::Map)
-          ::ActiveRecord::TypeCaster::Connection.include(ActiveRecord::TypeCaster::Connection)
-        end
+        ::ActiveRecord::Relation::WhereClauseFactory.prepend(ActiveRecord::WhereClauseFactory)
+        ::ActiveRecord::PredicateBuilder::AssociationQueryValue.prepend(ActiveRecord::PredicateBuilder::AssociationQueryValue)
+        ::ActiveRecord::TypeCaster::Map.include(ActiveRecord::TypeCaster::Map)
+        ::ActiveRecord::TypeCaster::Connection.include(ActiveRecord::TypeCaster::Connection)
 
         ::Rails.singleton_class.prepend(Rails::ClassMethods)
 

data/lib/switchman/r_spec_helper.rb

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

@@ -1,3 +1,3 @@
 module Switchman
-  VERSION = "1.10.4"
+  VERSION = "1.11.1"
 end

data/lib/tasks/switchman.rake

@@ -219,20 +219,6 @@ module Switchman
         run_cmd('pg_dump', args, 'dumping')
         File.open(filename, "a") { |f| f << "SET search_path TO #{serialized_search_path};\n\n" }
       end
-
-      if ::Rails.version < '4.2.5'
-        # These methods are backported from rails 4.2.5 to work with the above
-        def run_cmd(cmd, args, action)
-          fail run_cmd_error(cmd, args, action) unless Kernel.system(cmd, *args)
-        end
-
-        def run_cmd_error(cmd, args, action)
-          msg = "failed to execute:\n"
-          msg << "#{cmd} #{args.join(' ')}\n\n"
-          msg << "Please check the output above for any errors and make sure that `#{cmd}` is installed in your PATH and has proper permissions.\n\n"
-          msg
-        end
-      end
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: switchman
 version: !ruby/object:Gem::Version
-  version: 1.10.4
+  version: 1.11.1
 platform: ruby
 authors:
 - Cody Cutrer
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-05-07 00:00:00.000000000 Z
+date: 2017-07-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: railties
@@ -18,7 +18,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '4.2'
+        version: '5.0'
     - - "<"
       - !ruby/object:Gem::Version
         version: '5.2'
@@ -28,7 +28,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '4.2'
+        version: '5.0'
     - - "<"
       - !ruby/object:Gem::Version
         version: '5.2'
@@ -38,7 +38,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '4.2'
+        version: '5.0'
     - - "<"
       - !ruby/object:Gem::Version
         version: '5.2'
@@ -48,7 +48,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '4.2'
+        version: '5.0'
     - - "<"
       - !ruby/object:Gem::Version
         version: '5.2'
@@ -177,6 +177,7 @@ files:
 - db/migrate/20130328212039_create_switchman_shards.rb
 - db/migrate/20130328224244_create_default_shard.rb
 - db/migrate/20161206323434_add_back_default_string_limits_switchman.rb
+- db/shard_1708.sqlite3
 - lib/switchman.rb
 - lib/switchman/action_controller/caching.rb
 - lib/switchman/active_record/abstract_adapter.rb
@@ -243,7 +244,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.7.6
+rubygems_version: 2.6.10
 signing_key: 
 specification_version: 4
 summary: Rails 4 sharding magic