switchman 2.0.6 → 3.0.1

data/lib/switchman/active_record/reflection.rb

@@ -5,7 +5,7 @@ module Switchman
     module Reflection
       module AbstractReflection
         def shard(owner)
-          if polymorphic? || klass.shard_category == owner.class.shard_category
+          if polymorphic? || klass.connection_classes == owner.class.connection_classes
             # polymorphic associations assume the same shard as the owning item
             owner.shard
           else
@@ -28,21 +28,17 @@ module Switchman
         # 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, &block)
-          key = conn.prepared_statements
-          if polymorphic?
-            key = [key, owner._read_attribute(@foreign_type)]
-          end
+        def association_scope_cache(klass, owner, &block)
+          key = self
+          key = [key, owner._read_attribute(@foreign_type)] if polymorphic?
           key = [key, shard(owner).id].flatten
-          @association_scope_cache[key] ||= @scope_lock.synchronize {
-            @association_scope_cache[key] ||= (::Rails.version >= "5.2" ? ::ActiveRecord::StatementCache.create(conn, &block) : block.call)
-          }
+          klass.cached_find_by_statement(key, &block)
         end
       end
 
       module AssociationReflection
         def join_id_for(owner)
-          owner.send(::Rails.version >= "5.2" ? join_foreign_key : active_record_primary_key) # use sharded id values in association binds
+          owner.send(join_foreign_key) # use sharded id values in association binds
         end
       end
     end

data/lib/switchman/active_record/relation.rb

@@ -4,53 +4,54 @@ module Switchman
   module ActiveRecord
     module Relation
       def self.prepended(klass)
-        klass::SINGLE_VALUE_METHODS.concat [ :shard, :shard_source ]
+        klass::SINGLE_VALUE_METHODS.concat %i[shard shard_source]
       end
 
       def initialize(*, **)
         super
-        self.shard_value = Shard.current(klass ? klass.shard_category : :primary) unless shard_value
+        self.shard_value = Shard.current(klass ? klass.connection_classes : :primary) unless shard_value
         self.shard_source_value = :implicit unless shard_source_value
       end
 
       def clone
         result = super
-        result.shard_value = Shard.current(klass ? klass.shard_category : :primary) unless shard_value
+        result.shard_value = Shard.current(klass ? klass.connection_classes : :primary) unless shard_value
         result
       end
 
       def merge(*)
         relation = super
-        if relation.shard_value != self.shard_value && relation.shard_source_value == :implicit
-          relation.shard_value = self.shard_value
-          relation.shard_source_value = self.shard_source_value
+        if relation.shard_value != shard_value && relation.shard_source_value == :implicit
+          relation.shard_value = shard_value
+          relation.shard_source_value = shard_source_value
         end
         relation
       end
 
       def new(*, &block)
-        primary_shard.activate(klass.shard_category) { super }
+        primary_shard.activate(klass.connection_classes) { super }
       end
 
       def create(*, &block)
-        primary_shard.activate(klass.shard_category) { super }
+        primary_shard.activate(klass.connection_classes) { super }
       end
 
       def create!(*, &block)
-        primary_shard.activate(klass.shard_category) { super }
+        primary_shard.activate(klass.connection_classes) { super }
       end
 
       def to_sql
-        primary_shard.activate(klass.shard_category) { super }
+        primary_shard.activate(klass.connection_classes) { super }
       end
 
       def explain
-        self.activate { |relation| relation.call_super(:explain, Relation) }
+        activate { |relation| relation.call_super(:explain, Relation) }
       end
 
       def records
         return @records if loaded?
-        results = self.activate { |relation| relation.call_super(:records, Relation) }
+
+        results = activate { |relation| relation.call_super(:records, Relation) }
         case shard_value
         when Array, ::ActiveRecord::Relation, ::ActiveRecord::Base
           @records = results
@@ -59,7 +60,7 @@ module Switchman
         results
       end
 
-      %I{update_all delete_all}.each do |method|
+      %I[update_all delete_all].each do |method|
         class_eval <<-RUBY, __FILE__, __LINE__ + 1
           def #{method}(*args)
             result = self.activate { |relation| relation.call_super(#{method.inspect}, Relation, *args) }
@@ -74,15 +75,20 @@ module Switchman
         loose_mode = options[:loose] && is_integer
         # loose_mode: if we don't care about getting exactly batch_size ids in between
         # don't get the max - just get the min and add batch_size so we get that many _at most_
-        values = loose_mode ? "MIN(id)" : "MIN(id), MAX(id)"
+        values = loose_mode ? 'MIN(id)' : 'MIN(id), MAX(id)'
 
         batch_size = options[:batch_size].try(:to_i) || 1000
         quoted_primary_key = "#{klass.connection.quote_local_table_name(table_name)}.#{klass.connection.quote_column_name(primary_key)}"
-        as_id = " AS id" unless primary_key == 'id'
+        as_id = ' AS id' unless primary_key == 'id'
         subquery_scope = except(:select).select("#{quoted_primary_key}#{as_id}").reorder(primary_key.to_sym).limit(loose_mode ? 1 : batch_size)
         subquery_scope = subquery_scope.where("#{quoted_primary_key} <= ?", options[:end_at]) if options[:end_at]
 
-        first_subquery_scope = options[:start_at] ? subquery_scope.where("#{quoted_primary_key} >= ?", options[:start_at]) : subquery_scope
+        first_subquery_scope = if options[:start_at]
+                                 subquery_scope.where("#{quoted_primary_key} >= ?",
+                                                      options[:start_at])
+                               else
+                                 subquery_scope
+                               end
 
         ids = connection.select_rows("SELECT #{values} FROM (#{first_subquery_scope.to_sql}) AS subquery").first
 
@@ -99,16 +105,16 @@ module Switchman
 
       def activate(&block)
         shards = all_shards
-        if (Array === shards && shards.length == 1)
-          if shards.first == DefaultShard || shards.first == Shard.current(klass.shard_category)
+        if Array === shards && shards.length == 1
+          if shards.first == DefaultShard || shards.first == Shard.current(klass.connection_classes)
             yield(self, shards.first)
           else
-            shards.first.activate(klass.shard_category) { yield(self, shards.first) }
+            shards.first.activate(klass.connection_classes) { yield(self, shards.first) }
           end
         else
           # TODO: implement local limit to avoid querying extra shards
-          Shard.with_each_shard(shards, [klass.shard_category]) do
-            shard(Shard.current(klass.shard_category), :to_a).activate(&block)
+          Shard.with_each_shard(shards, [klass.connection_classes]) do
+            shard(Shard.current(klass.connection_classes), :to_a).activate(&block)
           end
         end
       end

data/lib/switchman/active_record/spawn_methods.rb

@@ -3,27 +3,27 @@
 module Switchman
   module ActiveRecord
     module SpawnMethods
-      def shard_values_for_merge(r)
-        if shard_value != r.shard_value
-          if r.shard_source_value == :implicit
+      def shard_values_for_merge(rhs)
+        if shard_value != rhs.shard_value
+          if rhs.shard_source_value == :implicit
             final_shard_value = shard_value
             final_primary_shard = primary_shard
             final_shard_source_value = shard_source_value
           elsif shard_source_value == :implicit
-            final_shard_value = r.shard_value
-            final_primary_shard = r.primary_shard
-            final_shard_source_value = r.shard_source_value
+            final_shard_value = rhs.shard_value
+            final_primary_shard = rhs.primary_shard
+            final_shard_source_value = rhs.shard_source_value
           else
-            final_shard_source_value = [:explicit, :association].detect do |source_value|
-              shard_source_value == source_value || r.shard_source_value == source_value
+            final_shard_source_value = %i[explicit association].detect do |source_value|
+              shard_source_value == source_value || rhs.shard_source_value == source_value
             end
-            raise "unknown shard_source_value" unless final_shard_source_value
+            raise 'unknown shard_source_value' unless final_shard_source_value
 
             # have to merge shard_value
             lhs_shard_value = all_shards
-            rhs_shard_value = r.all_shards
-            if (::ActiveRecord::Relation === lhs_shard_value &&
-                ::ActiveRecord::Relation === rhs_shard_value)
+            rhs_shard_value = rhs.all_shards
+            if ::ActiveRecord::Relation === lhs_shard_value &&
+               ::ActiveRecord::Relation === rhs_shard_value
               final_shard_value = lhs_shard_value.merge(rhs_shard_value)
               final_primary_shard = Shard.default
             else
@@ -32,27 +32,25 @@ module Switchman
               final_shard_value = final_shard_value.first if final_shard_value.length == 1
             end
           end
-        elsif shard_source_value != r.shard_source_value
-          final_shard_source_value = [:explicit, :association, :implicit].detect do |source_value|
-            shard_source_value == source_value || r.shard_source_value == source_value
+        elsif shard_source_value != rhs.shard_source_value
+          final_shard_source_value = %i[explicit association implicit].detect do |source_value|
+            shard_source_value == source_value || rhs.shard_source_value == source_value
           end
-          raise "unknown shard_source_value" unless final_shard_source_value
-        else
-          # nothing fancy
+          raise 'unknown shard_source_value' unless final_shard_source_value
         end
 
         [final_shard_value, final_primary_shard, final_shard_source_value]
       end
 
-      def merge!(r)
-        return super unless ::ActiveRecord::Relation === r
+      def merge!(rhs)
+        return super unless ::ActiveRecord::Relation === rhs
 
         # have to figure out shard stuff *before* conditions are merged
-        final_shard_value, final_primary_shard, final_shard_source_value = shard_values_for_merge(r)
+        final_shard_value, final_primary_shard, final_shard_source_value = shard_values_for_merge(rhs)
 
         return super unless final_shard_source_value
 
-        if !final_shard_value
+        unless final_shard_value
           super
           self.shard_source_value = final_shard_source_value
           return self
@@ -61,16 +59,16 @@ module Switchman
         return none! if final_shard_value == []
 
         # change the primary shard if necessary before merging
-        if primary_shard != final_primary_shard && r.primary_shard != final_primary_shard
+        if primary_shard != final_primary_shard && rhs.primary_shard != final_primary_shard
           shard!(final_primary_shard)
-          r = r.shard(final_primary_shard)
-          super(r)
+          rhs = rhs.shard(final_primary_shard)
+          super(rhs)
         elsif primary_shard != final_primary_shard
           shard!(final_primary_shard)
-          super(r)
-        elsif r.primary_shard != final_primary_shard
-          r = r.shard(final_primary_shard)
-          super(r)
+          super(rhs)
+        elsif rhs.primary_shard != final_primary_shard
+          rhs = rhs.shard(final_primary_shard)
+          super(rhs)
         else
           super
         end

data/lib/switchman/active_record/statement_cache.rb

@@ -7,18 +7,13 @@ module Switchman
         def create(connection, &block)
           relation = block.call ::ActiveRecord::StatementCache::Params.new
 
-          if ::Rails.version >= "5.2"
-            query_builder, binds = connection.cacheable_query(self, relation.arel)
-            bind_map = ::ActiveRecord::StatementCache::BindMap.new(binds)
-            new(relation.arel, bind_map, relation.klass)
-          else
-            bind_map = ::ActiveRecord::StatementCache::BindMap.new(relation.bound_attributes)
-            new relation.arel, bind_map
-          end
+          _query_builder, binds = connection.cacheable_query(self, relation.arel)
+          bind_map = ::ActiveRecord::StatementCache::BindMap.new(binds)
+          new(relation.arel, bind_map, relation.klass)
         end
       end
 
-      def initialize(arel, bind_map, klass=nil)
+      def initialize(arel, bind_map, klass = nil)
         @arel = arel
         @bind_map = bind_map
         @klass = klass
@@ -31,49 +26,39 @@ module Switchman
       # (e.g. infer from the primary key or use the current shard)
 
       def execute(*args)
-        if ::Rails.version >= '5.2'
-          params, connection = args
-          klass = @klass
-        else
-          params, klass, connection = args
-        end
+        params, connection = args
+        klass = @klass
         target_shard = nil
-        if primary_index = bind_map.primary_value_index
+        if (primary_index = bind_map.primary_value_index)
           primary_value = params[primary_index]
           target_shard = Shard.local_id_for(primary_value)[1]
         end
-        current_shard = Shard.current(klass.shard_category)
+        current_shard = Shard.current(klass.connection_classes)
         target_shard ||= current_shard
 
         bind_values = bind_map.bind(params, current_shard, target_shard)
 
-        target_shard.activate(klass.shard_category) do
+        target_shard.activate(klass.connection_classes) do
           sql = qualified_query_builder(target_shard, klass).sql_for(bind_values, connection)
           klass.find_by_sql(sql, bind_values)
         end
       end
 
-      if ::Rails.version < '5.2'
-        def qualified_query_builder(shard, klass)
-          @qualified_query_builders[shard.id] ||= klass.connection.cacheable_query(self.class, @arel)
-        end
-      else
-        def qualified_query_builder(shard, klass)
-          @qualified_query_builders[shard.id] ||= klass.connection.cacheable_query(self.class, @arel).first
-        end
+      def qualified_query_builder(shard, klass)
+        @qualified_query_builders[shard.id] ||= klass.connection.cacheable_query(self.class, @arel).first
       end
 
       module BindMap
         # performs id transposition here instead of query_methods.rb
         def bind(values, current_shard, target_shard)
           bas = @bound_attributes.dup
-          @indexes.each_with_index do |offset,i|
+          @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
+            new_value = if ba.is_a?(::ActiveRecord::Relation::QueryAttribute) && ba.value.sharded
+                          Shard.relative_id_for(values[i], current_shard, target_shard || current_shard)
+                        else
+                          values[i]
+                        end
             bas[offset] = ba.with_cast_value(new_value)
           end
           bas
@@ -83,9 +68,7 @@ module Switchman
           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
+          @indexes.index(primary_ba_index) if primary_ba_index
         end
       end
     end

data/lib/switchman/active_record/tasks/database_tasks.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Switchman
+  module ActiveRecord
+    module Tasks
+      module DatabaseTasks
+        def drop(*)
+          super
+          # no really, it's gone
+          Switchman.cache.delete('default_shard')
+          Shard.default(reload: true)
+        end
+      end
+    end
+  end
+end

data/lib/switchman/active_support/cache.rb

@@ -8,10 +8,8 @@ module Switchman
           store = super
           # can't use defined?, because it's a _ruby_ autoloaded constant,
           # so just checking that will cause it to get required
-          if store.class.name == "ActiveSupport::Cache::RedisCacheStore" && !::ActiveSupport::Cache::RedisCacheStore.ancestors.include?(RedisCacheStore)
-            ::ActiveSupport::Cache::RedisCacheStore.prepend(RedisCacheStore)
-          end
-          store.options[:namespace] ||= lambda { Shard.current.default? ? nil : "shard_#{Shard.current.id}" }
+          ::ActiveSupport::Cache::RedisCacheStore.prepend(RedisCacheStore) if store.instance_of?(ActiveSupport::Cache::RedisCacheStore) && !::ActiveSupport::Cache::RedisCacheStore.ancestors.include?(RedisCacheStore)
+          store.options[:namespace] ||= -> { Shard.current.default? ? nil : "shard_#{Shard.current.id}" }
           store
         end
       end
@@ -22,7 +20,7 @@ module Switchman
           # unfortunately, it uses the keys command, which is extraordinarily inefficient in a large redis instance
           # fortunately, we can assume we control the entire instance, because we set up the namespacing, so just
           # always unset it temporarily for clear calls
-          namespace = nil
+          namespace = nil # rubocop:disable Lint/ShadowedArgument
           super
         end
       end

data/lib/switchman/arel.rb

@@ -3,29 +3,34 @@
 module Switchman
   module Arel
     module Table
-      def model
-        type_caster.model
+      def klass
+        @klass || ::ActiveRecord::Base
       end
     end
+
     module Visitors
       module ToSql
-        def visit_Arel_Nodes_TableAlias *args
+        # rubocop:disable Naming/MethodName
+
+        def visit_Arel_Nodes_TableAlias(*args)
           o, collector = args
           collector = visit o.relation, collector
-          collector << " "
+          collector << ' '
           collector << quote_local_table_name(o.name)
         end
 
-        def visit_Arel_Attributes_Attribute *args
+        def visit_Arel_Attributes_Attribute(*args)
           o = args.first
           join_name = o.relation.table_alias || o.relation.name
           result = "#{quote_local_table_name join_name}.#{quote_column_name o.name}"
-          result = args.last << result
-          result
+          args.last << result
         end
 
-        def quote_local_table_name name
+        # rubocop:enable Naming/MethodName
+
+        def quote_local_table_name(name)
           return name if ::Arel::Nodes::SqlLiteral === name
+
           @connection.quote_local_table_name(name)
         end
       end

data/lib/switchman/database_server.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "securerandom"
+require 'securerandom'
 
 module Switchman
   class DatabaseServer
@@ -13,16 +13,22 @@ module Switchman
         database_servers.values
       end
 
+      def all_roles
+        @all_roles ||= all.map(&:roles).flatten.uniq
+      end
+
       def find(id_or_all)
-        return self.all if id_or_all == :all
-        return id_or_all.map { |id| self.database_servers[id || ::Rails.env] }.compact.uniq if id_or_all.is_a?(Array)
+        return all if id_or_all == :all
+        return id_or_all.map { |id| database_servers[id || ::Rails.env] }.compact.uniq if id_or_all.is_a?(Array)
+
         database_servers[id_or_all || ::Rails.env]
       end
 
       def create(settings = {})
-        raise "database servers should be set up in database.yml" unless ::Rails.env.test?
+        raise 'database servers should be set up in database.yml' unless ::Rails.env.test?
+
         id = settings[:id]
-        if !id
+        unless id
           @id ||= 0
           @id += 1
           id = @id
@@ -30,25 +36,42 @@ module Switchman
         server = DatabaseServer.new(id.to_s, settings)
         server.instance_variable_set(:@fake, true)
         database_servers[server.id] = server
+        ::ActiveRecord::Base.configurations.configurations <<
+          ::ActiveRecord::DatabaseConfigurations::HashConfig.new(::Rails.env, "#{server.id}/primary", settings)
+        Shard.send(:initialize_sharding)
+        server
       end
 
       def server_for_new_shard
         servers = all.select { |s| s.config[:open] }
         return find(nil) if servers.empty?
+
         servers[rand(servers.length)]
       end
 
       private
+
+      def reference_role(role)
+        return if all_roles.include?(role)
+
+        @all_roles << role
+        Shard.send(:initialize_sharding)
+      end
+
       def database_servers
         unless @database_servers
           @database_servers = {}.with_indifferent_access
-          if ::Rails.version >= '6.0'
-            ::ActiveRecord::Base.configurations.configurations.each do |config|
-              @database_servers[config.env_name] = DatabaseServer.new(config.env_name, config.config)
+          ::ActiveRecord::Base.configurations.configurations.each do |config|
+            if config.name.include?('/')
+              name, role = config.name.split('/')
+            else
+              name, role = config.env_name, config.name
             end
-          else
-            ::ActiveRecord::Base.configurations.each do |(id, config)|
-              @database_servers[id] = DatabaseServer.new(id, config)
+
+            if role == 'primary'
+              @database_servers[name] = DatabaseServer.new(config.env_name, config.configuration_hash)
+            else
+              @database_servers[name].roles << role
             end
           end
         end
@@ -56,15 +79,33 @@ module Switchman
       end
     end
 
+    attr_reader :roles
+
     def initialize(id = nil, config = {})
       @id = id
       @config = config.deep_symbolize_keys
       @configs = {}
+      @roles = [:primary]
+    end
+
+    def connects_to_hash
+      self.class.all_roles.map do |role|
+        config_role = role
+        config_role = :primary unless roles.include?(role)
+        config_name = :"#{id}/#{config_role}"
+        config_name = :primary if id == ::Rails.env && config_role == :primary
+        [role.to_sym, config_name]
+      end.to_h
     end
 
     def destroy
-      raise "database servers should be set up in database.yml" unless ::Rails.env.test?
-      self.class.send(:database_servers).delete(self.id) if self.id
+      self.class.send(:database_servers).delete(id) if id
+      Shard.sharded_models.each do |klass|
+        self.class.all_roles.each do |role|
+          klass.connection_handler.remove_connection_pool(klass.connection_specification_name, role: role,
+                                                                                               shard: id.to_sym)
+        end
+      end
     end
 
     def fake?
@@ -72,20 +113,20 @@ module Switchman
     end
 
     def config(environment = :primary)
-      @configs[environment] ||= begin
-        if @config[environment].is_a?(Array)
+      @configs[environment] ||=
+        case @config[environment]
+        when Array
           @config[environment].map do |config|
             config = @config.merge((config || {}).symbolize_keys)
             # make sure GuardRail doesn't get any brilliant ideas about choosing the first possible server
             config.delete(environment)
             config
           end
-        elsif @config[environment].is_a?(Hash)
+        when Hash
           @config.merge(@config[environment])
         else
           @config
         end
-      end
     end
 
     def guard_rail_environment
@@ -111,172 +152,109 @@ module Switchman
       guard!(old_env)
     end
 
-    def shareable?
-      @shareable_environment_key ||= []
-      environment = guard_rail_environment
-      explicit_user = ::GuardRail.global_config[:username]
-      return @shareable if @shareable_environment_key == [environment, explicit_user]
-      @shareable_environment_key = [environment, explicit_user]
-      if explicit_user
-        username = explicit_user
-      else
-        config = self.config(environment)
-        config = config.first if config.is_a?(Array)
-        username = config[:username]
-      end
-      @shareable = username !~ /%?\{[a-zA-Z0-9_]+\}/
-    end
-
     def shards
-      if self.id == ::Rails.env
-        Shard.where("database_server_id IS NULL OR database_server_id=?", self.id)
+      if id == ::Rails.env
+        Shard.where('database_server_id IS NULL OR database_server_id=?', id)
       else
-        Shard.where(:database_server_id => self.id)
+        Shard.where(database_server_id: id)
       end
     end
 
-    def pool_key
-      self.id == ::Rails.env ? nil : self.id
-    end
-
-    def create_new_shard(options = {})
-      raise NotImplementedError.new("Cannot create new shards when sharding isn't initialized") unless Shard.default.is_a?(Shard)
-
-      name = options[:name]
-      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
-
-      case config[:adapter]
-        when 'postgresql'
-          create_statement = lambda { "CREATE SCHEMA #{name}" }
-          password = " PASSWORD #{::ActiveRecord::Base.connection.quote(config[:password])}" if config[:password]
-        else
-          create_statement = lambda { "CREATE DATABASE #{name}" }
+    def create_new_shard(id: nil, name: nil, schema: true)
+      unless Shard.default.is_a?(Shard)
+        raise NotImplementedError,
+              "Cannot create new shards when sharding isn't initialized"
       end
+
+      create_statement = -> { "CREATE SCHEMA #{name}" }
+      password = " PASSWORD #{::ActiveRecord::Base.connection.quote(config[:password])}" if config[:password]
       sharding_config = Switchman.config
       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
         create_statement = lambda {
-          create_commands.map { |statement| statement.gsub('%{name}', name).gsub('%{password}', password || '') }
+          create_commands.map { |statement| format(statement, name: name, password: password) }
         }
       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
+      id ||= begin
+        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
+      end
 
-        if name.nil?
-          base_name = self.config[:database].to_s % self.config
-          base_name = nil if base_name == ':memory:'
-          base_name << '_' if base_name
-          base_id = shard_id || SecureRandom.uuid
-          name = "#{base_name}shard_#{base_id}"
-        end
+      name ||= "#{config[:database]}_shard_#{id}"
 
-        shard = Shard.create!(:id => shard_id,
-                              :name => name,
-                              :database_server => self)
+      Shard.connection.transaction do
+        shard = Shard.create!(id: id,
+                              name: name,
+                              database_server_id: self.id)
         schema_already_existed = false
 
         begin
           self.class.creating_new_shard = true
-          shard.activate(*Shard.categories) do
-            ::GuardRail.activate(:deploy) do
-              begin
-                if create_statement
-                  if (::ActiveRecord::Base.connection.select_value("SELECT 1 FROM pg_namespace WHERE nspname=#{::ActiveRecord::Base.connection.quote(name)}"))
-                    schema_already_existed = true
-                    raise "This schema already exists; cannot overwrite"
-                  end
-                  Array(create_statement.call).each do |stmt|
-                    ::ActiveRecord::Base.connection.execute(stmt)
-                  end
-                  # have to disconnect and reconnect to the correct db
-                  if self.shareable? && other_shard
-                    other_shard.activate { ::ActiveRecord::Base.connection }
-                  else
-                    ::ActiveRecord::Base.connection_pool.current_pool.disconnect!
-                  end
-                end
-                old_proc = ::ActiveRecord::Base.connection.raw_connection.set_notice_processor {} if config[:adapter] == 'postgresql'
-                old_verbose = ::ActiveRecord::Migration.verbose
-                ::ActiveRecord::Migration.verbose = false
-
-                unless create_schema == false
-                  reset_column_information
-
-                  migrate = ::Rails.version >= '5.2' ?
-                    -> { ::ActiveRecord::Base.connection.migration_context.migrate } :
-                    -> { ::ActiveRecord::Migrator.migrate(::ActiveRecord::Migrator.migrations_paths) }
-                  if ::ActiveRecord::Base.connection.supports_ddl_transactions?
-                    ::ActiveRecord::Base.connection.transaction(requires_new: true, &migrate)
-                  else
-                    migrate.call
-                  end
-                  reset_column_information
-                  ::ActiveRecord::Base.descendants.reject { |m| m == Shard || !m.table_exists? }.each(&:define_attribute_methods)
+          DatabaseServer.send(:reference_role, :deploy)
+          ::ActiveRecord::Base.connected_to(shard: self.id.to_sym, role: :deploy) do
+            if create_statement
+              if ::ActiveRecord::Base.connection.select_value("SELECT 1 FROM pg_namespace WHERE nspname=#{::ActiveRecord::Base.connection.quote(name)}")
+                schema_already_existed = true
+                raise 'This schema already exists; cannot overwrite'
+              end
+              Array(create_statement.call).each do |stmt|
+                ::ActiveRecord::Base.connection.execute(stmt)
+              end
+            end
+            if config[:adapter] == 'postgresql'
+              old_proc = ::ActiveRecord::Base.connection.raw_connection.set_notice_processor do
+              end
+            end
+            old_verbose = ::ActiveRecord::Migration.verbose
+            ::ActiveRecord::Migration.verbose = false
+
+            unless schema == false
+              shard.activate(*Shard.sharded_models) do
+                reset_column_information
+
+                ::ActiveRecord::Base.connection.transaction(requires_new: true) do
+                  ::ActiveRecord::Base.connection.migration_context.migrate
                 end
-              ensure
-                ::ActiveRecord::Migration.verbose = old_verbose
-                ::ActiveRecord::Base.connection.raw_connection.set_notice_processor(&old_proc) if old_proc
+                reset_column_information
+                ::ActiveRecord::Base.descendants.reject do |m|
+                  m <= UnshardedRecord || !m.table_exists?
+                end.each(&:define_attribute_methods)
               end
             end
+          ensure
+            ::ActiveRecord::Migration.verbose = old_verbose
+            ::ActiveRecord::Base.connection.raw_connection.set_notice_processor(&old_proc) if old_proc
           end
           shard
         rescue
           shard.destroy
-          unless schema_already_existed
-            shard.drop_database rescue nil
-          end
-          reset_column_information unless create_schema == false rescue nil
+          shard.drop_database rescue nil unless schema_already_existed
+          reset_column_information unless schema == false rescue nil
           raise
         ensure
           self.class.creating_new_shard = false
         end
       end
-
-      if Shard.connection.supports_ddl_transactions? && self.shareable? && other_shard
-        Shard.transaction do
-          other_shard.activate do
-            ::ActiveRecord::Base.connection.transaction(&create_shard)
-          end
-        end
-      else
-        create_shard.call
-      end
     end
 
     def cache_store
-      unless @cache_store
-        @cache_store = Switchman.config[:cache_map][self.id] || Switchman.config[:cache_map][::Rails.env]
-      end
+      @cache_store ||= Switchman.config[:cache_map][id] || Switchman.config[:cache_map][::Rails.env]
       @cache_store
     end
 
     def shard_name(shard)
-      if config[:shard_name]
-        config[:shard_name]
-      elsif config[:adapter] == 'postgresql'
-        if shard == :bootstrap
-          # rescue nil because the database may not exist yet; if it doesn't,
-          # it will shortly, and this will be re-invoked
-          ::ActiveRecord::Base.connection.current_schemas.first rescue nil
-        else
-          shard.activate { ::ActiveRecord::Base.connection_pool.default_schema }
-        end
+      return config[:shard_name] if config[:shard_name]
+
+      if shard == :bootstrap
+        # rescue nil because the database may not exist yet; if it doesn't,
+        # it will shortly, and this will be re-invoked
+        ::ActiveRecord::Base.connection.current_schemas.first rescue nil
       else
-        config[:database]
+        shard.activate { ::ActiveRecord::Base.connection_pool.default_schema }
       end
     end
 
@@ -290,9 +268,9 @@ module Switchman
     end
 
     private
+
     def reset_column_information
-      ::ActiveRecord::Base.descendants.reject { |m| m == Shard }.each(&:reset_column_information)
-      ::ActiveRecord::Base.connection_handler.switchman_connection_pool_proxies.each { |pool| pool.schema_cache.clear! }
+      ::ActiveRecord::Base.descendants.reject { |m| m <= UnshardedRecord }.each(&:reset_column_information)
     end
   end
 end