active_record_shards 3.11.0 → 3.19.0

data/lib/active_record_shards/default_slave_patches.rb

@@ -1,150 +1,5 @@
-# frozen_string_literal: true
-module ActiveRecordShards
-  module DefaultSlavePatches
-    def self.wrap_method_in_on_slave(class_method, base, method)
-      base_methods =
-        if class_method
-          base.methods + base.private_methods
-        else
-          base.instance_methods + base.private_instance_methods
-        end
-
-      return unless base_methods.include?(method)
-      _, method, punctuation = method.to_s.match(/^(.*?)([\?\!]?)$/).to_a
-      base.class_eval <<-RUBY, __FILE__, __LINE__ + 1
-        #{class_method ? 'class << self' : ''}
-          def #{method}_with_default_slave#{punctuation}(*args, &block)
-            on_slave_unless_tx do
-              #{method}_without_default_slave#{punctuation}(*args, &block)
-            end
-          end
-
-          alias_method :#{method}_without_default_slave#{punctuation}, :#{method}#{punctuation}
-          alias_method :#{method}#{punctuation}, :#{method}_with_default_slave#{punctuation}
-        #{class_method ? 'end' : ''}
-      RUBY
-    end
-
-    def columns_with_force_slave(*args, &block)
-      on_cx_switch_block(:slave, construct_ro_scope: false, force: true) do
-        columns_without_force_slave(*args, &block)
-      end
-    end
-
-    def table_exists_with_force_slave?(*args, &block)
-      on_cx_switch_block(:slave, construct_ro_scope: false, force: true) do
-        table_exists_without_force_slave?(*args, &block)
-      end
-    end
-
-    def transaction_with_slave_off(*args, &block)
-      if on_slave_by_default?
-        begin
-          old_val = Thread.current[:_active_record_shards_slave_off]
-          Thread.current[:_active_record_shards_slave_off] = true
-          transaction_without_slave_off(*args, &block)
-        ensure
-          Thread.current[:_active_record_shards_slave_off] = old_val
-        end
-      else
-        transaction_without_slave_off(*args, &block)
-      end
-    end
-
-    module InstanceMethods
-      # fix ActiveRecord to do the right thing, and use our aliased quote_value
-      def quote_value(*args, &block)
-        self.class.quote_value(*args, &block)
-      end
-
-      def reload_with_slave_off(*args, &block)
-        self.class.on_master { reload_without_slave_off(*args, &block) }
-      end
-    end
-
-    CLASS_SLAVE_METHODS = [:find_by_sql, :count_by_sql, :calculate, :find_one, :find_some, :find_every, :exists?].freeze
-
-    def self.extended(base)
-      CLASS_SLAVE_METHODS.each { |m| ActiveRecordShards::DefaultSlavePatches.wrap_method_in_on_slave(true, base, m) }
-
-      base.class_eval do
-        include InstanceMethods
-
-        alias_method :reload_without_slave_off, :reload
-        alias_method :reload, :reload_with_slave_off
+ActiveRecordShards::Deprecation.warn('`DefaultSlavePatches` is deprecated, please use `DefaultReplicaPatches`.')
 
-        class << self
-          alias_method :columns_without_force_slave, :columns
-          alias_method :columns, :columns_with_force_slave
-
-          alias_method :table_exists_without_force_slave?, :table_exists?
-          alias_method :table_exists?, :table_exists_with_force_slave?
-
-          alias_method :transaction_without_slave_off, :transaction
-          alias_method :transaction, :transaction_with_slave_off
-        end
-      end
-      if ActiveRecord::Associations.const_defined?(:HasAndBelongsToManyAssociation)
-        ActiveRecordShards::DefaultSlavePatches.wrap_method_in_on_slave(false, ActiveRecord::Associations::HasAndBelongsToManyAssociation, :construct_sql)
-        ActiveRecordShards::DefaultSlavePatches.wrap_method_in_on_slave(false, ActiveRecord::Associations::HasAndBelongsToManyAssociation, :construct_find_options!)
-      end
-    end
-
-    def on_slave_unless_tx
-      if on_slave_by_default? && !Thread.current[:_active_record_shards_slave_off]
-        on_slave { yield }
-      else
-        yield
-      end
-    end
-
-    module ActiveRelationPatches
-      def self.included(base)
-        [:calculate, :exists?, :pluck, :find_with_associations].each do |m|
-          ActiveRecordShards::DefaultSlavePatches.wrap_method_in_on_slave(false, base, m)
-        end
-      end
-
-      def on_slave_unless_tx
-        @klass.on_slave_unless_tx { yield }
-      end
-    end
-
-    module HasAndBelongsToManyPreloaderPatches
-      def self.included(base)
-        ActiveRecordShards::DefaultSlavePatches.wrap_method_in_on_slave(false, base, :records_for) rescue nil # rubocop:disable Style/RescueModifier
-      end
-
-      def on_slave_unless_tx
-        klass.on_slave_unless_tx { yield }
-      end
-
-      def exists_with_default_slave?(*args, &block)
-        on_slave_unless_tx { exists_without_default_slave?(*args, &block) }
-      end
-    end
-
-    # in rails 4.1+, they create a join class that's used to pull in records for HABTM.
-    # this simplifies the hell out of our existence, because all we have to do is inerit on-slave-by-default
-    # down from the parent now.
-    module Rails41HasAndBelongsToManyBuilderExtension
-      def self.included(base)
-        base.class_eval do
-          alias_method :through_model_without_inherit_default_slave_from_lhs, :through_model
-          alias_method :through_model, :through_model_with_inherit_default_slave_from_lhs
-        end
-      end
-
-      def through_model_with_inherit_default_slave_from_lhs
-        model = through_model_without_inherit_default_slave_from_lhs
-        def model.on_slave_by_default?
-          left_reflection.klass.on_slave_by_default?
-        end
-
-        # also transfer the sharded-ness of the left table to the join model
-        model.not_sharded unless model.left_reflection.klass.is_sharded?
-        model
-      end
-    end
-  end
+module ActiveRecordShards
+  DefaultSlavePatches = DefaultReplicaPatches
 end

data/lib/active_record_shards/deprecation.rb

@@ -0,0 +1,12 @@
+module ActiveRecordShards
+  class Deprecation < ActiveSupport::Deprecation
+    # This allows us to define separate deprecation behavior for ActiveRecordShards, but defaults to
+    # the same behavior globally configured with ActiveSupport.
+    #
+    # For example, this allows us to silence our own deprecation warnings in test while still being
+    # able to fail tests for upstream deprecation warnings.
+    def behavior
+      @behavior ||= ActiveSupport::Deprecation.behavior
+    end
+  end
+end

data/lib/active_record_shards/migration.rb

@@ -1,43 +1,50 @@
 # frozen_string_literal: true
+
 module ActiveRecord
   class Migrator
-    class << self
-      [:up, :down, :run].each do |m|
-        define_method("#{m}_with_sharding") do |*args|
-          ActiveRecord::Base.on_shard(nil) do
-            send("#{m}_without_sharding", *args)
-          end
-          ActiveRecord::Base.on_all_shards do
-            send("#{m}_without_sharding", *args)
-          end
-        end
-        alias_method :"#{m}_without_sharding", m.to_sym
-        alias_method m.to_sym, :"#{m}_with_sharding"
+    def self.shards_migration_context
+      if ActiveRecord::VERSION::MAJOR >= 6
+        ActiveRecord::MigrationContext.new(ActiveRecord::Migrator.migrations_paths, ActiveRecord::SchemaMigration)
+      elsif ActiveRecord::VERSION::STRING >= '5.2.0'
+        ActiveRecord::MigrationContext.new(ActiveRecord::Migrator.migrations_paths)
+      else
+        self
       end
+    end
 
-      def bootstrap_migrations_from_nil_shard(migrations_path, this_migration = nil)
-        migrations = nil
-        ActiveRecord::Base.on_shard(nil) do
-          migrations = ActiveRecord::Migrator.new(:up, migrations_path).migrated
-        end
+    def initialize_with_sharding(*args)
+      initialize_without_sharding(*args)
 
-        puts "inserting #{migrations.size} migrations on all shards..."
-        ActiveRecord::Base.on_all_shards do
-          migrator = ActiveRecord::Migrator.new(:up, migrations_path)
-          migrations.each do |m|
-            migrator.__send__(:record_version_state_after_migrating, m)
-          end
-          if this_migration
-            migrator.__send__(:record_version_state_after_migrating, this_migration)
-          end
+      # Rails creates the internal tables on the unsharded DB. We make them
+      # manually on the sharded DBs.
+      ActiveRecord::Base.on_all_shards do
+        ActiveRecord::SchemaMigration.create_table
+        if ActiveRecord::VERSION::MAJOR >= 5
+          ActiveRecord::InternalMetadata.create_table
         end
       end
     end
+    alias_method :initialize_without_sharding, :initialize
+    alias_method :initialize, :initialize_with_sharding
+
+    def run_with_sharding
+      ActiveRecord::Base.on_shard(nil) { run_without_sharding }
+      ActiveRecord::Base.on_all_shards { run_without_sharding }
+    end
+    alias_method :run_without_sharding, :run
+    alias_method :run, :run_with_sharding
+
+    def migrate_with_sharding
+      ActiveRecord::Base.on_shard(nil) { migrate_without_sharding }
+      ActiveRecord::Base.on_all_shards { migrate_without_sharding }
+    end
+    alias_method :migrate_without_sharding, :migrate
+    alias_method :migrate, :migrate_with_sharding
 
     # don't allow Migrator class to cache versions
     undef migrated
     def migrated
-      self.class.get_all_versions
+      self.class.shards_migration_context.get_all_versions
     end
 
     # list of pending migrations is any migrations that haven't run on all shards.
@@ -56,7 +63,7 @@ module ActiveRecord
       missing = {}
 
       collect = lambda do |shard|
-        migrated = get_all_versions
+        migrated = shards_migration_context.get_all_versions
 
         p = versions - migrated
         pending[shard] = p if p.any?
@@ -82,9 +89,6 @@ module ActiveRecordShards
     end
   end
 
-  # ok, so some 'splaining to do.  Rails 3.1 puts the migrate() method on the instance of the
-  # migration, where it should have been.  But this makes our monkey patch incompatible.
-  # So we're forced to *either* include or extend this.
   module ActualMigrationExtension
     def migrate_with_forced_shard(direction)
       if migration_shard.blank?

data/lib/active_record_shards/model.rb

@@ -6,10 +6,11 @@ module ActiveRecordShards
       if self != ActiveRecord::Base && self != base_class
         raise "You should only call not_sharded on direct descendants of ActiveRecord::Base"
       end
+
       self.sharded = false
     end
 
-    def is_sharded? # rubocop:disable Style/PredicateName
+    def is_sharded? # rubocop:disable Naming/PredicateName
       if self == ActiveRecord::Base
         sharded != false && supports_sharding?
       elsif self == base_class
@@ -23,23 +24,38 @@ module ActiveRecordShards
       end
     end
 
-    def on_slave_by_default?
-      base_class.instance_variable_get(:@on_slave_by_default)
+    def on_replica_by_default?
+      if self == ActiveRecord::Base
+        false
+      else
+        base = base_class
+        if base.instance_variable_defined?(:@on_replica_by_default)
+          base.instance_variable_get(:@on_replica_by_default)
+        end
+      end
     end
+    alias_method :on_slave_by_default?, :on_replica_by_default?
 
-    def on_slave_by_default=(value)
-      base_class.instance_variable_set(:@on_slave_by_default, value)
+    def on_replica_by_default=(value)
+      if self == ActiveRecord::Base
+        raise ArgumentError, "Cannot set on_replica_by_default on ActiveRecord::Base"
+      else
+        base_class.instance_variable_set(:@on_replica_by_default, value)
+      end
     end
+    alias_method :on_slave_by_default=, :on_replica_by_default=
 
     module InstanceMethods
-      def initialize_shard_and_slave
-        @from_slave = !!self.class.current_shard_selection.options[:slave]
+      def initialize_shard_and_replica
+        @from_replica = !!self.class.current_shard_selection.options[:replica]
         @from_shard = self.class.current_shard_selection.options[:shard]
       end
+      alias_method :initialize_shard_and_slave, :initialize_shard_and_replica
 
-      def from_slave?
-        @from_slave
+      def from_replica?
+        @from_replica
       end
+      alias_method :from_slave?, :from_replica?
 
       def from_shard
         @from_shard
@@ -48,7 +64,7 @@ module ActiveRecordShards
 
     def self.extended(base)
       base.send(:include, InstanceMethods)
-      base.after_initialize :initialize_shard_and_slave
+      base.after_initialize :initialize_shard_and_replica
     end
 
     private

data/lib/active_record_shards/patches-4-2.rb

@@ -1,13 +1,9 @@
 # frozen_string_literal: true
+
 require 'active_record_shards/connection_pool'
 require 'active_record_shards/connection_handler'
 require 'active_record_shards/connection_specification'
-require 'active_record_shards/schema_dumper_extension'
 
 ActiveRecordShards::ConnectionSpecification = ActiveRecord::ConnectionAdapters::ConnectionSpecification
 methods_to_override = [:establish_connection, :remove_connection, :pool_for, :pool_from_any_process_for]
 ActiveRecordShards.override_connection_handler_methods(methods_to_override)
-
-ActiveRecord::Associations::Builder::HasAndBelongsToMany.include(ActiveRecordShards::DefaultSlavePatches::Rails41HasAndBelongsToManyBuilderExtension)
-
-ActiveRecord::SchemaDumper.prepend(ActiveRecordShards::SchemaDumperExtension)

data/lib/active_record_shards/schema_dumper_extension.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module ActiveRecordShards
   module SchemaDumperExtension
     def dump(stream)
@@ -23,15 +24,15 @@ module ActiveRecordShards
     def shard_header(stream)
       define_params = @version ? "version: #{@version}" : ""
 
-      stream.puts <<HEADER
+      stream.puts <<~HEADER
 
 
-# This section generated by active_record_shards
+        # This section generated by active_record_shards
 
-ActiveRecord::Base.on_all_shards do
-ActiveRecord::Schema.define(#{define_params}) do
+        ActiveRecord::Base.on_all_shards do
+        ActiveRecord::Schema.define(#{define_params}) do
 
-HEADER
+      HEADER
     end
 
     def shard_trailer(stream)

data/lib/active_record_shards/shard_selection.rb

@@ -1,11 +1,12 @@
 # frozen_string_literal: true
+
 module ActiveRecordShards
   class ShardSelection
     NO_SHARD = :_no_shard
     cattr_accessor :default_shard
 
     def initialize
-      @on_slave = false
+      @on_replica = false
       @shard = nil
     end
 
@@ -21,17 +22,17 @@ module ActiveRecordShards
         end
       end
 
-      def shard_name(klass = nil, try_slave = true)
+      def shard_name(klass = nil, try_replica = true)
         the_shard = shard(klass)
 
         @shard_names ||= {}
         @shard_names[ActiveRecordShards.rails_env] ||= {}
         @shard_names[ActiveRecordShards.rails_env][the_shard] ||= {}
-        @shard_names[ActiveRecordShards.rails_env][the_shard][try_slave] ||= {}
-        @shard_names[ActiveRecordShards.rails_env][the_shard][try_slave][@on_slave] ||= begin
+        @shard_names[ActiveRecordShards.rails_env][the_shard][try_replica] ||= {}
+        @shard_names[ActiveRecordShards.rails_env][the_shard][try_replica][@on_replica] ||= begin
           s = ActiveRecordShards.rails_env.dup
           s << "_shard_#{the_shard}" if the_shard
-          s << "_slave"              if @on_slave && try_slave
+          s << "_replica"            if @on_replica && try_replica
           s
         end
       end
@@ -46,25 +47,24 @@ module ActiveRecordShards
         end
       end
 
-      PRIMARY = "primary".freeze
+      PRIMARY = "primary"
       def resolve_connection_name(sharded:, configurations:)
         resolved_shard = sharded ? shard : nil
-
-        if !resolved_shard && !@on_slave
-          return PRIMARY
-        end
-
-        @shard_names ||= {}
-        @shard_names[ActiveRecordShards.rails_env] ||= {}
-        @shard_names[ActiveRecordShards.rails_env][resolved_shard] ||= {}
-        @shard_names[ActiveRecordShards.rails_env][resolved_shard][@on_slave] ||= begin
-          s = ActiveRecordShards.rails_env.dup
-          s << "_shard_#{resolved_shard}" if resolved_shard
-
-          if @on_slave && configurations["#{s}_slave"] # fall back to master connection
-            s << "_slave"
+        env = ActiveRecordShards.rails_env
+
+        @connection_names ||= {}
+        @connection_names[env] ||= {}
+        @connection_names[env][resolved_shard] ||= {}
+        @connection_names[env][resolved_shard][@on_replica] ||= begin
+          name = env.dup
+          name << "_shard_#{resolved_shard}" if resolved_shard
+          if @on_replica && configurations["#{name}_replica"]
+            "#{name}_replica"
+          else
+            # ActiveRecord always names its default connection pool 'primary'
+            # while everything else is named by the configuration name
+            resolved_shard ? name : PRIMARY
           end
-          s
         end
       end
 
@@ -74,16 +74,18 @@ module ActiveRecordShards
       @shard = (new_shard || NO_SHARD)
     end
 
-    def on_slave?
-      @on_slave
+    def on_replica?
+      @on_replica
     end
+    alias_method :on_slave?, :on_replica?
 
-    def on_slave=(new_slave)
-      @on_slave = (new_slave == true)
+    def on_replica=(new_replica)
+      @on_replica = (new_replica == true)
     end
+    alias_method :on_slave=, :on_replica=
 
     def options
-      { shard: @shard, slave: @on_slave }
+      { shard: @shard, replica: @on_replica }
     end
   end
 end

data/lib/active_record_shards/shard_support.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module ActiveRecordShards
   class ShardSupport
     class ShardEnumerator

data/lib/active_record_shards/sql_comments.rb

@@ -1,16 +1,23 @@
-# show which connection was picked to debug master/slave slowness when both servers are the same
+# show which connection was picked to debug primary/replica slowness when both servers are the same
 module ActiveRecordShards
   module SqlComments
     module Methods
       def execute(query, name = nil)
-        slave = ActiveRecord::Base.current_shard_selection.on_slave?
-        query += " /* #{slave ? 'slave' : 'master'} */"
+        shard = ActiveRecord::Base.current_shard_selection.shard
+        shard_text = shard ? "shard #{shard}" : 'unsharded'
+        replica = ActiveRecord::Base.current_shard_selection.on_replica?
+        replica_text = replica ? 'replica' : 'primary'
+        query = "/* #{shard_text} #{replica_text} */ " + query
         super(query, name)
       end
     end
 
     def self.enable
-      ActiveRecord::Base.connection.class.prepend(Methods)
+      ActiveRecord::Base.on_replica do
+        ActiveRecord::Base.on_shard(nil) do
+          ActiveRecord::Base.connection.class.prepend(Methods)
+        end
+      end
     end
   end
 end

data/lib/active_record_shards/tasks.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require 'active_record_shards'
 
 %w[db:drop db:create db:abort_if_pending_migrations db:reset db:test:purge].each do |name|
@@ -8,15 +9,16 @@ end
 namespace :db do
   desc 'Drops the database for the current RAILS_ENV including shards'
   task drop: :load_config do
-    ActiveRecord::Base.configurations.each do |key, conf|
-      next if !key.starts_with?(ActiveRecordShards.rails_env) || key.ends_with?("_slave")
+    ActiveRecord::Base.configurations.to_h.each do |key, conf|
+      next if !key.start_with?(ActiveRecordShards.rails_env) || key.end_with?("_replica", "_slave")
+
       begin
         ActiveRecordShards::Tasks.root_connection(conf).drop_database(conf['database'])
       # rescue ActiveRecord::NoDatabaseError # TODO: exists in AR but never is raised here ...
       #   $stderr.puts "Database '#{conf['database']}' does not exist"
-      rescue StandardError => error
-        $stderr.puts error, *error.backtrace
-        $stderr.puts "Couldn't drop #{conf['database']}"
+      rescue StandardError => e
+        warn e, *e.backtrace
+        warn "Couldn't drop #{conf['database']}"
       end
     end
   end
@@ -28,25 +30,22 @@ namespace :db do
 
   desc "Create the database defined in config/database.yml for the current RAILS_ENV including shards"
   task create: :load_config do
-    ActiveRecord::Base.configurations.each do |key, conf|
-      next if !key.starts_with?(ActiveRecordShards.rails_env) || key.ends_with?("_slave")
-      if ActiveRecord::VERSION::MAJOR >= 4
-        begin
-          # MysqlAdapter takes charset instead of encoding in Rails 4
-          # https://github.com/rails/rails/commit/78b30fed9336336694fb2cb5d2825f95800b541c
-          symbolized_configuration = conf.symbolize_keys
-          symbolized_configuration[:charset] = symbolized_configuration[:encoding]
+    ActiveRecord::Base.configurations.to_h.each do |key, conf|
+      next if !key.start_with?(ActiveRecordShards.rails_env) || key.end_with?("_replica", "_slave")
+
+      begin
+        # MysqlAdapter takes charset instead of encoding in Rails 4.2 or greater
+        # https://github.com/rails/rails/blob/4-2-stable/activerecord/lib/active_record/tasks/mysql_database_tasks.rb#L85-L96
+        symbolized_configuration = conf.symbolize_keys
+        symbolized_configuration[:charset] = symbolized_configuration[:encoding]
 
-          ActiveRecordShards::Tasks.root_connection(conf).create_database(conf['database'], symbolized_configuration)
-        rescue ActiveRecord::StatementInvalid => ex
-          if ex.message.include?('database exists')
-            puts "#{conf['database']} already exists"
-          else
-            raise ex
-          end
+        ActiveRecordShards::Tasks.root_connection(conf).create_database(conf['database'], symbolized_configuration)
+      rescue ActiveRecord::StatementInvalid => e
+        if e.message.include?('database exists')
+          puts "#{conf['database']} already exists"
+        else
+          raise e
         end
-      else
-        create_database(conf)
       end
     end
     ActiveRecord::Base.establish_connection(ActiveRecordShards.rails_env.to_sym)
@@ -56,16 +55,20 @@ namespace :db do
   task abort_if_pending_migrations: :environment do
     if defined? ActiveRecord
       pending_migrations =
-        if Rails::VERSION::MAJOR >= 4
-          ActiveRecord::Base.on_shard(nil) { ActiveRecord::Migrator.open(ActiveRecord::Migrator.migrations_paths).pending_migrations }
+        if ActiveRecord::VERSION::MAJOR >= 6
+          migrations = ActiveRecord::MigrationContext.new(ActiveRecord::Migrator.migrations_paths, ActiveRecord::SchemaMigration).migrations
+          ActiveRecord::Migrator.new(:up, migrations, ActiveRecord::SchemaMigration).pending_migrations
+        elsif ActiveRecord::VERSION::STRING >= "5.2.0"
+          migrations = ActiveRecord::MigrationContext.new(ActiveRecord::Migrator.migrations_paths).migrations
+          ActiveRecord::Migrator.new(:up, migrations).pending_migrations
         else
-          ActiveRecord::Base.on_shard(nil) { ActiveRecord::Migrator.new(:up, 'db/migrate').pending_migrations }
+          ActiveRecord::Base.on_shard(nil) { ActiveRecord::Migrator.open(ActiveRecord::Migrator.migrations_paths).pending_migrations }
         end
 
       if pending_migrations.any?
-        puts "You have #{pending_migrations.size} pending migrations:"
+        warn "You have #{pending_migrations.size} pending migrations:"
         pending_migrations.each do |pending_migration|
-          puts '  %4d %s' % [pending_migration.version, pending_migration.name]
+          warn '  %4d %s' % [pending_migration.version, pending_migration.name]
         end
         abort %(Run "rake db:migrate" to update your database then try again.)
       end
@@ -89,17 +92,19 @@ end
 
 module ActiveRecordShards
   module Tasks
-    if ActiveRecord::VERSION::MAJOR < 5
-      def self.root_connection(conf)
-        ActiveRecord::Base.send("#{conf['adapter']}_connection", conf.merge('database' => nil))
-      end
-    else
-      def self.root_connection(conf)
-        # this will trigger rails to load the adapter
+    class << self
+      def root_connection(conf)
         conf = conf.merge('database' => nil)
+        spec = spec_for(conf)
+
+        ActiveRecord::Base.send("#{conf['adapter']}_connection", spec.config)
+      end
+
+      private
+
+      def spec_for(conf)
         resolver = ActiveRecord::ConnectionAdapters::ConnectionSpecification::Resolver.new(ActiveRecord::Base.configurations)
         resolver.spec(conf)
-        ActiveRecord::Base.send("#{conf['adapter']}_connection", conf)
       end
     end
   end