connection_manager 1.0.4 → 1.1.0

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    MTEwZjBmOTI5ZTVjMTI0OGJkZDQwODg0NzcwYTIzZGUxYTI5M2M4NQ==
+    MGZjYTQyMmJjZDkyODU2MDMyYWU4OGJmYjRkZTg4ZmNjMmM3YmYwNw==
   data.tar.gz: !binary |-
-    ZGJjMWY5YWU4Zjc0OTI3MWMxMTczYTAwMTNmYzI0MTY2OGJhYTEyNQ==
+    MjVhMjBlN2NhZGU3ZmVlYmJiOGRjODUxZmYwMDFjOTE3N2I3OGI0ZA==
 SHA512:
   metadata.gz: !binary |-
-    NjIxODExY2IwYzEzY2Y4MjU3ODAyMGVhZTZmYTM0YTcwODAzMDYxMWYyNjU5
-    NWE3N2M2YzBkYTYxYzk3ZDdiYzA5NzgzYjQ0ODU5Y2E5MmMwMDM5OWU5MTA4
-    MGUzMGNiNjE3NDdiNGYwYzUwYjZlM2NhNWM3ZDAyOWE2ZWQxYzE=
+    NjFmMDZkNDE3NjgxMWU2NTRiNDZlMGZhMmJkN2JmZmE4YjQwMDdhY2UxMDY3
+    NDEzYmM0OTk2MmZlNGRiNTYyZWM4ZWE4OTc1MTc3NjRmY2ZhMzI1OTk5YWQ3
+    MWNkYjY2MGNmNDdjMTdhMjZhODE1ZWY4ZTE5NTRmZDRlNDMzMGE=
   data.tar.gz: !binary |-
-    NGFiOWQ5NTQyZGYyZmNkYzQ0NWI0ZjVmYjg3NDhmZTE1YjY5MzVlY2Y0NmFh
-    OTY1ZTczNjE5ZWFlZDU4YmQ5OWIxZmUxNmMyYzI2MTg3N2QzNmMwOWIzMmY0
-    NTI1ZGUzNWFiNWJhZDc3ZjQ0NGFjZjEwYTNkYzU1MjhjOWUzZjE=
+    MzYwMjJjMzU5NWRlODk3MGRjMmEzMWI2ODJkNThkMGRiMjUzNWE1NmMxMjQ5
+    YzkzMjQzNjAyMmEzZDg5MTVmMjI0ZWMwMDdhMjcyY2E4ZjVmZTY2OWFkZTVi
+    MGI5MWUwZTkxYTAyZTZlYWYwZjBlMmZmYzE2MDkwMzE0MTYxMjE=

data/CHANGE.md

@@ -3,7 +3,18 @@ ConnectionManager Changelog
 
 HEAD
 =======
-- None yet!
+- Nothing yet!
+
+1.1.0
+=======
+- BREAKING CHANGE - Code has been organized to mirror as much a possible their ActiveRecord 4 counter parts.
+- BREAKING CHANGE - creates AR::Relation for :slaves and :masters, replication method names are no longer customizable
+- BREAKING CHANGE - Drop support for forced readonly, should be enforced by DMS and or using #readonly ActiveRecord::Relation
+- BREAKING CHANGE - Drop use_schema in favor of schema_name=
+- BREAKING CHANGE - Drop current_database_name in favor of schema_name
+- Make sure all connections are checked in to managed_connections by patch establish_connection
+- Use thread-safe for managed_connections
+- Don't try and fetch schema using query, too slow and buggy, we want a light weight implementation, but still get it from database.yml if Mysql and not set
 
 1.0.4
 =======

data/README.md

@@ -1,15 +1,10 @@
 # ConnectionManager
-Multi-Database, Replication and Sharding for ActiveRecord.
-
-## Background
-ActiveRecord, for quite some time now, has supported multiple database connections 
-through the use of #establish_connection and connection classes [more info](http://api.rubyonrails.org/classes/ActiveRecord/Base.html)
-Multiple databases, replication and shards can be implemented directly in rails without
-patching, but a gem helps to reduce redundant code and ensure consistency. 
-ConnectionManager replaces all the connection classes and subclasses required 
-for multiple database support in Rails with a few class methods and simple 
-database.yml configuration. Since ConnectionManager does not alter
-ActiveRecord's connection pool, thread safety is not a concern.
+Improved cross-schema, replication and mutli-DMS gem for ActiveRecord.
+
+## Features
+  * Threadsafe connection switching
+  * Replication can be defined in the database.yml or in the model, adds #slaves and #masters as ActiveRecord::Relations.
+  * Automatically builds connection classes, if configured.
 
 ## Installation
 
@@ -31,129 +26,152 @@ Run bundle install:
 
     common: &common
     adapter: mysql2
-    username: root
-    password: *****
     pool: 20
-    connect_timeout: 20
-    timeout: 900
+    reconnect: true
     socket: /tmp/mysql.sock
-    build_connection_class: true
-  
-    development:
-      <<: *common
-      database: test_app
-      slaves: [slave_1_test_app_development, slave_2_test_app_development]
-
-    slave_1_test_app_development:
-      <<: *common
-      database: test_app
-      readonly: true
   
-    slave_2_test_app_development:
+    production:
       <<: *common
-      database: test_app
-      readonly: true
-
-    user_data_development
+      database: myapp
+      host: <%=ENV['DB_HOST']%>
+      username: <%=ENV['DB_USER']%>
+      password: <%=ENV['DB_PASS']%>
+      slaves: [slave_1_production, slave_2_production]   
+      build_connection_class: true
+
+    slave_1_production:
       <<: *common
-      database: user_data
-      slaves: [slave_1_user_data_development, slave_2_user_data_development]
+      host: <%=ENV['SLAVE_1_DB_HOST']%>
+      username: <%=ENV['SLAVE_1_DB_USER']%>
+      password: <%=ENV['SLAVE_1_DB_PASS']%>
+      database: myapp
+      build_connection_class: true
 
-    slave_1_user_data_development
+    slave_2_production:
       <<: *common
-      database: user_data
-      readonly: true
+     host: <%=ENV['SLAVE_2_DB_HOST']%>
+      username: <%=ENV['SLAVE_2_DB_USER']%>
+      password: <%=ENV['SLAVE_2_DB_PASS']%>
+      database: myapp
+      build_connection_class: true
 
-    slave_2_user_data_development
+    foo_data_production
       <<: *common
+      host: <%=ENV['USER_DATA_DB_HOST']%>
+      username: <%=ENV['USER_DATA_DB_USER']%>
+      password: <%=ENV['USER_DATA_DB_PASS']%>
       database: user_data
-      readonly: true
+      build_connection_class: true
 
 In the above database.yml the Master databases are listed as "development" and "user_data_development".
-Replication databases are defined as normally connections and are added to the 'replications:' option for
-their master. The readonly option ensures all ActiveRecord objects returned from this connection are ALWAYS readonly.
-
+Replication databases are defined as normally connections and are added to the `replication_connections` for
+their master.
 
 ## Building Connection Classes
 
 ### Manually   
-ConnectionManager provides establish_managed_connection for build connection 
-classes and connection to multiple databases.
+ConnectionManager provides `establish_managed_connection` for build connection 
+classes and connection to multiple databases. The `establish_managed_connection method`, 
+runs `establish_connection` with the supplied database.yml key, sets `abstract_class` to true.
 
-    class MyConnection < ActiveRecord::Base
-      establish_managed_connection("my_database_#{Rails.env}", :readonly => true)
+    class MySlaveConnection < ActiveRecord::Base
+      establish_managed_connection("slave_1_#{Rails.env}")
     end
     
-    class User < MyConnection
-    end
+    class User < MySlaveConnection;end
     
-    MyConnection    => MyConnection(abstract)
+    MyConnection      # => MyConnection(abstract)
     @user = User.first
-    @user.readonly? => true
-
-The establish_managed_connection method, runs establish_connection with the supplied
-database.yml key, sets abstract_class to true, and (since :readonly is set to true) ensures
-all ActiveRecord objects build using this connection class are readonly. If readonly is set
-to true in the database.yml, passing the readonly option is not necessary.  
+    @user             # => #<User id:1>
 
 
+    
 ### Automatically   
 ActiveRecord can build all your connection classes for you. 
-The connection class names will be based on the database.yml keys.ActiveRecord will
+The connection class names will be based on the database.yml keys. ActiveRecord will
 build connection classes for all the entries in the database.yml where 
-"build_connection_class" is true, and match the current environment settings
+`build_connection_class: = true`, and match the current environment settings
+
+    # Class names derived from YML keys
+    'production'           = 'BaseConnection'
+    'slave_1_production'   = 'Save1Connection'
+    'slave_2_production'   = 'Save2Connection'
+    'foo_data_production'  = 'FooDataConnection'
+
 
 ## Using 
 
 The using method allows you specify the connection class to use
-for query. The return objects will have the correct model name, but the instance's
-class's superclass will be the connection class and all database actions performed 
-on the instance will use the connection class's connection.
+for query. 
     
     User.using("Slave1Connection").first
 
     search = User.where(disabled => true)
-    @legacy_users = search.using("Shard1Connection").all #=> [<User::Shard1ConnectionDup...>,<User::Shard1ConnectionDup..]
-    @legacy_users.first.save #=> uses the Shard1Connection connection
+    @legacy_users = search.using("Slave1Connection").all # => [<User...>,<User...>]
+    @legacy_users.first.save #=> uses the SlaveConnection connection
 
     @new_users = search.page(params[:page]).all => [<User...>,<User...>]
 
 ## Replication
 
-Simply add 'replicated' to your model.
+ConnectionManager creates ActiveRecord::Relation methods :slaves and :masters.
+
+If you specify your replication model in your database.yml there is nothing more you need to do. If you looking for more
+granular control you describe the replication setup on a per-model level.
     
     class User < UserDataConnection
         has_one :job
         has_many :teams
-        replicated # implement replication        
-        # model code ...
+        replicated :slaves => [MySlave1Connection, MySlave2Connection]
     end
 
-The replicated method builds models who inherit from the main model.
-    User::Slave1UserDataConnectionDup.superclass => Slave1UserDataConnection(abstract)
-    User::Slave1UserDataDup.first => returns results from slave_1_user_data_development 
-    User::Slave2UserDataDup.where(['created_at BETWEEN ? and ?',Time.now - 3.hours, Time.now]).all => returns results from slave_2_user_data_development
+    User.limit(2).slaves.all # => [<User...>,<User...>] results from MySlave1Connection or MySlave2Connection 
 
-Finally, ConnectionManager creates an additional class method that shifts through your 
-available slave connections each time it is called using a different connection on each action.
+
+If there are multiple replication connections the system will pick a connection at random using Array#sample.
     
     User.slaves.first  => returns results from slave_1_use_data_development 
-    User.slaves.last =>  => returns results from slave_2_use_data_development 
-    User.slaves.where(['created_at BETWEEN ? and ?',Time.now - 3.hours, Time.now]).all  => returns results from slave_1_user_data_development 
-    User.slaves.where(['created_at BETWEEN ? and ?',Time.now - 5.days, Time.now]).all  => returns results from slave_2_user_data_development 
+    User.slaves.last => returns results from slave_2_user_data_development  
+    User.slaves.where('id BETWEEN ? and ?',1,100]).all  => returns results from slave_1_user_data_development 
+    User.slaves.where('id BETWEEN ? and ?',1,100]).all  => returns results from slave_2_user_data_development 
 
-Replicated defaults to the slaves replication type,so if you have only masters and a combination
-of masters and slaves for replication, you have set the replication type to masters
+### Repliation with cross-schema queries
+Setup replication as you would normally
 
-    class User < UserDataConnection
-        replicated #slaves replication
-        replicated :type => :masters, :name => 'masters' # masters replication
+Next build connection classes that inherit from you base connection classes for each of your schemas
+EX
+    class UserSchema < ActiveRecord::Base
+      self.abstract_class = true
+      self.table_name_prefix = 'user_schema.'
+
+      def self.inherited(base)
+        base.use_schema(self.schema_name)
+      end
+    end
+
+    class User < UserSchema
+      has_many :bars
+    end
+
+    class FooSchema < ActiveRecord::Base
+      self.abstract_class = true
+      self.table_name_prefix = 'foo.'
+
+      def self.inherited(base)
+        base.use_schema(self.schema_name)
+      end
     end
 
+    class Bar < FooSchema
+      belongs_to :user
+    end
+
+    User.joins(:bars).limit(1).to_sql # => SELECT * FROM `user_schema`.`users` INNER JOIN `foo.bars` ON `foo.bars`.`user_id` = `user_schema`.`users` LIMIT 1"
+
 ## Sharding
 
 After tinkering with some solutions for shards, I've come to a similar conclusion as [DataFabric] (https://github.com/mperham/data_fabric):
-"Sharding should be implemented at the application level". The #shards method is very basic and
+"Sharding should be implemented at the application level". The `shards` method is very basic and
 while it may be useful to most folks, it should really serve as an example of a possible solutions
 to your shard requirements.
 
@@ -176,7 +194,7 @@ originate from classes that used establish_connection you must surround your cod
       Some queries...
     }
 
-In Rails for less complicated schemas you could simply create an around filter for your controllers
+In Rails, you can create an around filter for your controllers
 
     class ApplicationController < ActionController::Base
       around_filter :cache_slaves
@@ -186,8 +204,7 @@ In Rails for less complicated schemas you could simply create an around filter f
       end
 
 ## Migrations
-
-Nothing implement now to help but there are lots of potential solutions [here] (http://stackoverflow.com/questions/1404620/using-rails-migration-on-different-database-than-standard-production-or-devel)
+There are lots of potential solutions [here] (http://stackoverflow.com/questions/1404620/using-rails-migration-on-different-database-than-standard-production-or-devel)
 
 ## TODOs
 * Maybe add migration support for Rails AR implementations.

data/connection_manager.gemspec

@@ -8,8 +8,8 @@ Gem::Specification.new do |s|
   s.authors     = ["Joshua Mckinney"]
   s.email       = ["joshmckin@gmail.com"]
   s.homepage    = ""
-  s.summary     = %q{Simplifies connecting to Multiple and Replication databases with rails and active_record}
-  s.description = %q{Simplifies connecting to Multiple and Replication databases with rails and active_record}
+  s.summary     = %q{Cross-schema, replication and mutli-DMS gem for ActiveRecord.}
+  s.description = %q{Improves support for cross-schema, replication and mutli-DMS applications using ActiveRecord.}
 
   s.rubyforge_project = "connection_manager"
 
@@ -18,16 +18,12 @@ Gem::Specification.new do |s|
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
   s.add_runtime_dependency 'activerecord', '>= 3.0', '<= 4.1'
-  s.add_development_dependency 'rspec'
+  s.add_runtime_dependency 'activesupport', '>= 3.0', '<= 4.1'
+  s.add_runtime_dependency 'thread_safe'
+  s.add_development_dependency 'rspec', '~> 2.0'
   s.add_development_dependency 'autotest'
   s.add_development_dependency 'mocha'
   s.add_development_dependency 'factory_girl'
-  s.add_development_dependency 'activesupport', '>= 3.0', '<= 4.1'
-  
-  if(defined? RUBY_ENGINE and 'jruby' == RUBY_ENGINE)
-    s.add_development_dependency 'jruby-openssl'
-    s.add_development_dependency 'activerecord-jdbcmysql-adapter'
-  else
-    s.add_development_dependency "mysql2"
-  end
+  s.add_development_dependency 'mysql2'
+  s.add_development_dependency 'pg'
 end

data/lib/connection_manager/builder.rb

@@ -0,0 +1,56 @@
+module ConnectionManager
+  class Builder
+    class << self
+      # Grab only those configurations that correspond to the current env (If env
+      # is blank it grabs all the connection keys) and where :build_connection_class is true
+      def database_keys_for_auto_build
+        ActiveRecord::Base.configurations.select{ |k,v| v[:build_connection_class] && k.match(env_regex)}.keys
+      end
+
+      # Builds connection classes using the database keys provided; expects an array.
+      def build_connection_classes(database_keys_to_use=database_keys_for_auto_build)
+        database_keys_to_use.each do |key|
+          build_connection_class(connection_class_name(key),key.to_sym)
+        end
+      end
+
+      # Build connection classes base on the supplied class name and connection
+      # key from database.yml
+      def build_connection_class(class_name,connection_key)
+        begin
+          class_name.constantize
+        rescue NameError
+          klass = Class.new(ActiveRecord::Base)
+          new_connection_class = Object.const_set(class_name, klass)
+          new_connection_class.abstract_class = true
+          new_connection_class.establish_connection(connection_key.to_sym)
+          ConnectionManager.logger.info "Connection::Manager built: #{class_name} for #{connection_key}" if ConnectionManager.logger
+          new_connection_class
+        end
+      end
+
+      def env_regex
+        return @env_regex if @env_regex
+        s = "#{ConnectionManager.env}$"
+        @env_regex = Regexp.new("(#{s})")
+      end
+
+      private
+      # Creates a string to be used for the class name. Removes the current env.
+      def clean_yml_key(name)
+        new_name = "#{name}".gsub(env_regex,'')
+        new_name = "Base" if new_name.blank?
+        new_name.gsub(/\_$/,'')
+      end
+
+      # Given an connection key name from the database.yml, returns the string
+      # equivalent of the class name for that entry.
+      def connection_class_name(name_from_yml)
+        new_class_name = clean_yml_key(name_from_yml)
+        new_class_name = new_class_name.gsub(/\_/,' ').titleize.gsub(/ /,'')
+        new_class_name << "Connection"
+        new_class_name
+      end
+    end
+  end
+end

data/lib/connection_manager/connection_adapters/abstract_adapter.rb

@@ -0,0 +1,50 @@
+module ConnectionManager
+  module AbstractAdapter
+    def config
+      @config
+    end
+    # Determines if connection supports cross database queries
+    def cross_schema_support?
+      @cross_schema_support ||= (config[:adapter].match(/(mysql)|(postgres)|(sqlserver)/i))
+    end
+    alias :cross_database_support? :cross_schema_support?
+
+    def mysql?
+      @is_mysql ||= (config[:adapter].match(/(mysql)/i))
+    end
+
+    def postgresql?
+      @is_postgresql ||= (config[:adapter].match(/(postgres)/i))
+    end
+
+    def sqlserver?
+      @is_sqlserver ||= (config[:adapter].match(/(sqlserver)/i))
+    end
+
+    def replicated?
+      (!slave_keys.blank? || !master_keys.blank?)
+    end
+
+    def database_name
+      config[:database]
+    end
+
+    def slave_keys
+      @slave_keys ||= (config[:slaves] ? config[:slaves].collect{|r| r.to_sym} : [] )
+    end
+
+    def master_keys
+      @master_keys ||= (config[:masters] ? config[:masters].collect{|r| r.to_sym} : [])
+    end
+
+    def replication_keys(type=:slaves)
+      return slave_keys if type == :slaves
+      master_keys
+    end
+
+    def replications
+      {:slaves => slave_keys, :masters => master_keys}
+    end
+  end
+end
+ActiveRecord::ConnectionAdapters::AbstractAdapter.send(:include,(ConnectionManager::AbstractAdapter))

data/lib/connection_manager/connection_adapters/mysql_adapter.rb

@@ -0,0 +1,39 @@
+module ConnectionManager
+  module MysqlAdapter
+
+    # Force all tables to be cached for the life connection
+    def cached_tables
+      @cached_tables ||= {}
+    end
+
+    def new_tables(name = nil, database = nil, like =nil)
+      return cached_tables[database] if cached_tables[database] && like.nil?
+      cached_tables[database] ||= []
+      return [like] if like && cached_tables[database].include?(like)
+      sql = "SHOW TABLES "
+      sql << "IN #{database} " if database
+      sql << "LIKE #{quote(like)}" if like
+      result = execute(sql, 'SCHEMA')
+      cached_tables[database] = (cached_tables[database] | result.collect { |field| field[0] }).compact
+    end
+    alias :tables :new_tables
+
+
+    # We have to clean the name of '`' and fetch table name with schema
+    def table_exists?(name)
+      return false unless name
+      name          = name.to_s
+      schema, table = name.split('.', 2)
+      unless table # A table was provided without a schema
+        table  = schema
+        schema = nil
+      end
+      new_tables(nil, schema, table).include?(table)
+    end
+  end
+end
+if ActiveRecord::VERSION::MAJOR == 3 && ActiveRecord::VERSION::MINOR <= 1
+  require 'active_record/connection_adapters/mysql2_adapter'
+  ActiveRecord::ConnectionAdapters::MysqlAdapter.send(:include,(ConnectionManager::MysqlAdapter)) if defined?(ActiveRecord::ConnectionAdapters::MysqlAdapter)
+  ActiveRecord::ConnectionAdapters::Mysql2Adapter.send(:include,(ConnectionManager::MysqlAdapter))
+end

data/lib/connection_manager/connection_handling.rb

@@ -0,0 +1,91 @@
+require 'thread'
+require 'active_record/relation'
+module ConnectionManager
+  module ConnectionHandling
+    @@managed_connections = ThreadSafe::Cache.new
+
+    # Attempts to return the schema from table_name and table_name_prefix
+    def schema_name
+      return self.table_name.split('.')[0] if self.table_name && self.table_name.match(/\./)
+      return self.table_name_prefix.to_s.gsub(/\./,'') if self.table_name_prefix && self.table_name_prefix.match(/\./)
+      return self.connection.config[:database] if self.connection.mysql?
+    end
+    alias :database_name :schema_name
+
+    # Set the unformatted schema name for the given model / connection class
+    # EX: class User < ActiveRecord::Base
+    #       self.schema_name = 'users_db'
+    #     end
+    #
+    #     User.schema_name        # => 'users_db'
+    #     User.table_name_prefix  # => 'users_db.'
+    #     User.table_name         # => 'users_db.users'
+    def schema_name=schema_name
+      self.table_name_prefix = "#{schema_name}." if schema_name && schema_name.to_s != ""
+      self.table_name = "#{self.table_name_prefix}#{self.table_name}" unless self.abstract_class?
+    end
+    alias :database_name= :schema_name=
+
+    # A place to store managed connections
+    def managed_connections
+      @@managed_connections
+    end
+
+    def managed_connection_classes
+      managed_connections.values.flatten
+    end
+
+    # Establishes and checks in a connection, normally for abstract classes AKA connection classes.
+    #
+    # Options:
+    # * :abstract_class - used the set #abstract_class, default is true
+    # * :schema_name - the unformatted schema name for connection, is inherited but child classes
+    # * :table_name - the table name for the model, should not be used on abstract classes
+    #
+    # EX:
+    #   class MyConnection < ActiveRecord::Base
+    #     establish_managed_connection :key_from_db_yml,{:readonly => true}
+    #   end
+    #
+    def establish_managed_connection(yml_key,opts={})
+      opts = {:class_name => self.name,
+              :abstract_class => true}.merge(opts)
+      establish_connection(yml_key)
+      self.abstract_class = opts[:abstract_class]
+      self.table_name = opts[:table_name] if opts[:table_name]
+      if (opts[:schema_name] || opts[:database_name])
+        self.schema_name = (opts[:schema_name] || opts[:database_name])
+      else
+        self.schema_name = self.schema_name unless !self.connection.cross_schema_support?
+      end
+    end
+
+    def self.included(base)
+      base.alias_method_chain :establish_connection, :managed_connections
+    end
+
+    def self.extended(base)
+      class << base
+        self.alias_method_chain :establish_connection, :managed_connections
+      end
+    end
+
+    def establish_connection_with_managed_connections(spec = nil)
+      result = establish_connection_without_managed_connections(spec)
+      if spec && (spec.is_a?(Symbol) || spec.is_a?(String))
+        self.managed_connections[spec.to_sym] = self.name
+      elsif spec.nil? && ConnectionManager.env
+        self.managed_connections[ConnectionManager.env.to_sym] = self.name
+      else
+        self.managed_connections[self.name] = self.name
+      end
+      result
+    end
+  end
+end
+if ActiveRecord::VERSION::MAJOR == 4
+  ActiveRecord::ConnectionHandling.send(:include, ConnectionManager::ConnectionHandling)
+else
+  require 'active_record/base'
+  ActiveRecord::Base.extend(ConnectionManager::ConnectionHandling)
+end

data/lib/connection_manager/core.rb

@@ -0,0 +1,24 @@
+module ConnectionManager
+  module Core
+    # We want to make sure we get the full table name with schema
+    def arel_table_with_check_name # :nodoc:
+      @arel_table = Arel::Table.new(table_name, arel_engine) unless (@arel_table && (@arel_table.name == self.table_name))
+      @arel_table
+    end
+
+    def self.included(base)
+      base.alias_method_chain :arel_table, :check_name
+    end
+
+    def self.extended(base)
+      class << base
+        self.alias_method_chain :arel_table, :check_name
+      end
+    end
+  end
+end
+if ActiveRecord::VERSION::MAJOR == 4
+  ActiveRecord::Core::ClassMethods.send(:include,ConnectionManager::Core)
+else
+  ActiveRecord::Base.extend ConnectionManager::Core
+end

data/lib/connection_manager/querying.rb

@@ -0,0 +1,13 @@
+require 'active_support/core_ext/module/delegation'
+module ConnectionManager
+  module Querying
+    delegate :using, :to => (ActiveRecord::VERSION::MAJOR == 4 ? :all : :scoped)
+    delegate :slaves, :to => (ActiveRecord::VERSION::MAJOR == 4 ? :all : :scoped)
+    delegate :masters, :to => (ActiveRecord::VERSION::MAJOR == 4 ? :all : :scoped)
+  end
+end
+if ActiveRecord::VERSION::MAJOR == 4
+  ActiveRecord::Querying.send(:include, ConnectionManager::Querying)
+else
+  ActiveRecord::Base.send(:extend, ConnectionManager::Querying)
+end

data/lib/connection_manager/railtie.rb

@@ -0,0 +1,10 @@
+module ConnectionManager
+  class Railtie < ::Rails::Railtie
+    initializer "connection_manager.build_connection_classes" do
+      require 'connection_manager/connection_adapters/mysql_adapter' if (ActiveRecord::VERSION::MAJOR == 3 && ActiveRecord::VERSION::MINOR <= 1 && (defined?(Mysql2::VERSION) || defined?(Mysql2::VERSION)))
+      ConnectionManager.env = Rails.env
+      ConnectionManager.logger = Rails.logger
+      ConnectionManager::Builder.build_connection_classes(Rails.application.config.database_configuration.select{ |k,v| v['build_connection_class'] && k.match(ConnectionManager::Builder.env_regex)}.keys)
+    end
+  end
+end

data/lib/connection_manager/relation.rb

@@ -0,0 +1,21 @@
+module ConnectionManager
+  module Relation
+    # Specify connection class to used for query. For
+    # example:
+    #
+    # users = User.using(MySlaveConnection).first
+    def using(connection_class_name)
+      @klass = ConnectionManager::Using::Proxy.new(@klass,connection_class_name)
+      self
+    end
+
+    def slaves
+      using(@klass.send(:fetch_slave_connection))
+    end
+
+    def masters
+      using(@klass.send(:fetch_master_connection))
+    end
+  end
+end
+ActiveRecord::Relation.send(:include, ConnectionManager::Relation)