connection_manager 0.2.1 → 0.2.2

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    connection_manager (0.2.1)
+    connection_manager (0.2.2)
       activerecord (~> 3.0)
 
 GEM

data/README.md

@@ -120,6 +120,7 @@ available slave connections each time it is called using a different connection
 
 ## TODO's
 * sharding - IN 2.0 AS BETA
+* cross schema joins - 2.2 AS BETA tested with Mysql2 ONLY
 
 ## Other activerecord Connection gems
 * [Octopus](https://github.com/tchandy/octopus)

data/lib/connection_manager.rb

@@ -6,10 +6,11 @@ module ConnectionManager
   require 'connection_manager/associations'
   require 'connection_manager/secondary_connection_builder'
   require 'connection_manager/method_recorder'
-  require 'connection_manager/connection_manager_railtie.rb' if defined?(Rails) 
+  require 'connection_manager/connection_manager_railtie' if defined?(Rails) 
     
   ActiveRecord::Base.extend(ConnectionManager::Associations) 
   ActiveRecord::Base.extend(ConnectionManager::SecondaryConnectionBuilder)
   
+  require 'connection_manager/cross_schema_patch.rb' if (ActiveRecord::VERSION::MAJOR == 3 && ActiveRecord::VERSION::MINOR == 0)
 end
 

data/lib/connection_manager/connections.rb

@@ -114,6 +114,7 @@ module ConnectionManager
           self.abstract_class = true
         end
         new_connection_class = Object.const_set(class_name, klass)
+        new_connection_class.table_name_prefix=("#{ActiveRecord::Base.configurations[connection_key]['database']}.")
         new_connection_class.establish_connection(connection_key)       
         (const_set class_name, new_connection_class)
         all << class_name

data/lib/connection_manager/cross_schema_patch.rb

@@ -0,0 +1,130 @@
+### https://github.com/rails/rails/issues/539
+### http://tamersalama.com/2010/09/27/nomethoderror-undefined-method-eq-for-nilnilclass/
+### https://github.com/rails/rails/blob/3-0-stable/activerecord/lib/active_record/associations.rb
+# ActiveRecord 3.0 ONLY
+
+if ActiveRecord::VERSION::MAJOR == 3 && ActiveRecord::VERSION::MINOR == 0
+
+  module ActiveRecord
+    module Associations 
+      module ClassMethods
+        class JoinDependency     
+          class JoinAssociation < JoinBase 
+            
+            def table_name_without_schema(t_name)
+              t_name.to_s.gsub(/.*\./, '')
+            end
+          
+            def association_join
+              return @join if @join
+              aliased_table = Arel::Table.new(table_name.to_s.gsub(/.*\./, ''), :as   => @aliased_table_name.to_s.gsub(/.*\./, ''),
+                :engine  => arel_engine,
+                :columns => klass.columns)
+    
+              parent_table = Arel::Table.new(parent.table_name.to_s.gsub(/.*\./, ''), :as => parent.aliased_table_name.to_s.gsub(/.*\./, ''),
+                :engine  => arel_engine,
+                :columns => parent.active_record.columns)
+              as_conditions = reflection.options[:conditions] && process_conditions(reflection.options[:conditions], aliased_table_name)      
+            
+              @join = case reflection.macro
+            
+              when :has_and_belongs_to_many
+                join_table = Arel::Table.new(options[:join_table], :as => aliased_join_table_name, :engine => arel_engine)
+                fk = options[:foreign_key] || reflection.active_record.to_s.foreign_key
+                klass_fk = options[:association_foreign_key] || klass.to_s.foreign_key
+
+                [
+                  join_table[fk].eq(parent_table[reflection.active_record.primary_key]),
+                  [aliased_table[klass.primary_key].eq(join_table[klass_fk]), as_conditions].reject{ |x| x.blank? }
+                ]
+              when :has_many, :has_one
+                if reflection.options[:through]
+                  join_table = Arel::Table.new(through_reflection.klass.table_name, :as => aliased_join_table_name, :engine => arel_engine)
+                  jt_as_conditions = through_reflection.options[:conditions] && process_conditions(through_reflection.options[:conditions], aliased_table_name)
+                  jt_as_extra = jt_source_extra = jt_sti_extra = nil
+                  first_key = second_key = as_extra = nil
+
+                  if through_reflection.macro == :belongs_to
+                    jt_primary_key = through_reflection.primary_key_name
+                    jt_foreign_key = through_reflection.association_primary_key
+                  else
+                    jt_primary_key = through_reflection.active_record_primary_key
+                    jt_foreign_key = through_reflection.primary_key_name
+
+                    if through_reflection.options[:as] # has_many :through against a polymorphic join
+                      jt_as_extra = join_table[through_reflection.options[:as].to_s + '_type'].eq(parent.active_record.base_class.name)
+                    end
+                  end
+
+                  case source_reflection.macro
+                  when :has_many, :has_one
+                    if source_reflection.options[:as]
+                      first_key   = "#{source_reflection.options[:as]}_id"
+                      second_key  = options[:foreign_key] || primary_key
+                      as_extra    = aliased_table["#{source_reflection.options[:as]}_type"].eq(source_reflection.active_record.base_class.name)
+                    else
+                      first_key   = through_reflection.klass.base_class.to_s.foreign_key
+                      second_key  = options[:foreign_key] || primary_key
+                    end
+
+                    unless through_reflection.klass.descends_from_active_record?
+                      jt_sti_extra = join_table[through_reflection.active_record.inheritance_column].eq(through_reflection.klass.sti_name)
+                    end
+                  when :belongs_to
+                    first_key = primary_key
+                    if reflection.options[:source_type]
+                      second_key = source_reflection.association_foreign_key
+                      jt_source_extra = join_table[reflection.source_reflection.options[:foreign_type]].eq(reflection.options[:source_type])
+                    else
+                      second_key = source_reflection.primary_key_name
+                    end
+                  end
+                  [
+                    [parent_table[jt_primary_key].eq(join_table[jt_foreign_key]), jt_as_extra, jt_source_extra, jt_sti_extra, jt_as_conditions].reject{|x| x.blank? },
+                    [aliased_table[first_key].eq(join_table[second_key]), as_extra, as_conditions].reject{ |x| x.blank? }
+                  ]
+                elsif reflection.options[:as]
+                  id_rel = aliased_table["#{reflection.options[:as]}_id"].eq(parent_table[parent.primary_key])
+                  type_rel = aliased_table["#{reflection.options[:as]}_type"].eq(parent.active_record.base_class.name)
+                  [id_rel, type_rel, as_conditions].reject{ |x| x.blank?}
+                else
+                  foreign_key = options[:foreign_key] || reflection.active_record.name.foreign_key
+                  [aliased_table[foreign_key].eq(parent_table[reflection.options[:primary_key] || parent.primary_key]), as_conditions].reject{ |x| x.blank? }
+                end
+              when :belongs_to
+                #aliased_table[options[:primary_key] || reflection.klass.primary_key].eq(parent_table[options[:foreign_key] || reflection.primary_key_name]), as_conditions].reject{ |x| x.blank? }
+            
+                [aliased_table[options[:primary_key] || reflection.klass.primary_key].eq(find_belongs_to_arel_column(parent_table)), as_conditions].reject{ |x| x.blank? }
+           
+              end
+
+              unless klass.descends_from_active_record?
+                sti_column = aliased_table[klass.inheritance_column]
+                sti_condition = sti_column.eq(klass.sti_name)
+                klass.descendants.each {|subclass| sti_condition = sti_condition.or(sti_column.eq(subclass.sti_name)) }
+
+                @join << sti_condition
+              end
+
+              @join
+            end
+
+            def find_belongs_to_arel_column(parent_table)
+              parent_table.columns.select{|c| (c.name == options[:foreign_key].to_sym)}[0] ||
+                parent_table.columns.select{|c| (c.name == reflection.primary_key_name.to_sym)}[0]
+            end
+          end
+        end
+      end
+    end
+  end
+  
+  module Arel
+    class Table
+      private
+      def table_exists?
+        @table_exists ||= tables.key?(@name.to_s.gsub(/.*\./, '')) || engine.connection.table_exists?(name.to_s.gsub(/.*\./, ''))
+      end
+    end
+  end
+end

data/lib/connection_manager/secondary_connection_builder.rb

@@ -1,6 +1,6 @@
 module ConnectionManager
   module SecondaryConnectionBuilder
-    
+   
     def database_name
       "#{connection.instance_variable_get(:@config)[:database].to_s}"
     end
@@ -77,9 +77,9 @@ module ConnectionManager
             method_name = method_name.insert(method_name.index(/\d/),"_")
             class_name = method_name.classify
             connection_methods << method_name.to_sym
+#            set_table_name_for_joins
             build_secondary_class(class_name,c,options)
-            build_single_secondary_method(method_name,class_name)
-            #set_table_name_for_joins
+            build_single_secondary_method(method_name,class_name)            
             sub_classes << "#{self.name}::#{class_name}".constantize if options[:shards]
           end
         end
@@ -125,13 +125,18 @@ module ConnectionManager
           end
         end
       STR
-      
+      connection_sub_classes << sub_class
+      puts connection_sub_classes
       sub_class
     end
     
-#    def set_table_name_for_joins
-#      self.table_name_prefix = "#{database_name}." unless database_name.match(/\.sqlite3$/)
-#    end
+    def connection_sub_classes
+      @connection_sub_classes ||= []
+    end
+    
+    def set_table_name_for_joins
+      self.table_name_prefix = "#{database_name}." unless database_name.match(/\.sqlite3$/)
+    end
     
     # Adds as class method to call a specific secondary conneciton.
     # Usage:

data/lib/connection_manager/version.rb

@@ -1,4 +1,4 @@
 module ConnectionManager
-  VERSION = "0.2.1"
+  VERSION = "0.2.2"
 end
 

data/spec/helpers/database_spec_helper.rb

@@ -18,11 +18,12 @@ end
 class TestMigrations < ActiveRecord::Migration  
   
   # all the ups
-  def self.up(connection_name='test')  
+  def self.up(connection_name='test', user_connection_name='cm_user_test')  
     ActiveRecord::Base.establish_connection(connection_name) 
     begin
       create_table :foos do |t|
         t.string :name
+        t.integer :user_id
       end 
       create_table :fruits do |t|
         t.string :name
@@ -50,12 +51,19 @@ class TestMigrations < ActiveRecord::Migration
     rescue => e
       puts "tables failed to create: #{e}"
     end
-  
+    ActiveRecord::Base.establish_connection(user_connection_name)
+    begin
+      create_table :users do |t|
+        t.string :name
+      end
+    rescue => e
+      puts "tables failed to create: #{e}"
+    end
+    ActiveRecord::Base.establish_connection(connection_name)
   end
   
- 
   # all the downs
-  def self.down(connection_name='test')  
+  def self.down(connection_name='test',user_connection_name='cm_user_test')  
     ActiveRecord::Base.establish_connection(connection_name) 
     begin
       [:foos,:fruits,:baskets,:fruit_baskets,:regions,:types].each do |t|
@@ -64,7 +72,14 @@ class TestMigrations < ActiveRecord::Migration
     rescue => e
       puts "tables were not dropped: #{e}"
     end
-  end 
-  
-  
+    ActiveRecord::Base.establish_connection(user_connection_name) 
+    begin
+      [:users].each do |t|
+        drop_table t 
+      end
+    rescue => e
+      puts "tables were not dropped: #{e}"
+    end
+    ActiveRecord::Base.establish_connection(connection_name)  
+  end  
 end 

data/spec/helpers/models_spec_helper.rb

@@ -1,10 +1,10 @@
+
 class Basket < ActiveRecord::Base
   has_many :fruit_baskets
   has_many :fruit, :through => :fruit_baskets
   #replicated
 end
 
-
 class Fruit < ActiveRecord::Base
   belongs_to :region
   has_many :fruit_baskets

data/spec/lib/secondary_connection_builder_spec.rb

@@ -10,29 +10,29 @@ describe ConnectionManager::SecondaryConnectionBuilder do
 
   context '#other_association_options' do
     
-      it "should add :class_name options set to the replication subclass if :class_name is blank" do
-        options = Fruit.secondary_association_options(:has_one, :plant, 'Slave')
-        options[:class_name].should eql("Plant::Slave")
-      end
+    it "should add :class_name options set to the replication subclass if :class_name is blank" do
+      options = Fruit.secondary_association_options(:has_one, :plant, 'Slave')
+      options[:class_name].should eql("Plant::Slave")
+    end
       
-      it "should append :class_name with the replication subclass if :class_name is not bank" do
-        options = Fruit.secondary_association_options(:has_one, :plant, 'Slave', :class_name => 'Plant')
-        options[:class_name].should eql("Plant::Slave")
-      end
+    it "should append :class_name with the replication subclass if :class_name is not bank" do
+      options = Fruit.secondary_association_options(:has_one, :plant, 'Slave', :class_name => 'Plant')
+      options[:class_name].should eql("Plant::Slave")
+    end
     
     context "has_one or has_many" do
-    it "should add the :foreign_key if the :foreign_key options is not present" do
-      options = Fruit.secondary_association_options(:has_one, :plant, 'Slave')
-      options[:foreign_key].should eql('fruit_id')
-      options = Fruit.secondary_association_options(:has_many, :plant, 'Slave')
-      options[:foreign_key].should eql('fruit_id')
-    end
+      it "should add the :foreign_key if the :foreign_key options is not present" do
+        options = Fruit.secondary_association_options(:has_one, :plant, 'Slave')
+        options[:foreign_key].should eql('fruit_id')
+        options = Fruit.secondary_association_options(:has_many, :plant, 'Slave')
+        options[:foreign_key].should eql('fruit_id')
+      end
     end
   end
   
   context '#secondary_connection_classes' do
     it "should return the :using array with the array elements classified and append with Connection" do
-     Fruit.secondary_connection_classes({:using => ['slave_1_test_db','slave_2_test_db']}).
+      Fruit.secondary_connection_classes({:using => ['slave_1_test_db','slave_2_test_db']}).
         should eql(["Slave1TestDbConnection", "Slave2TestDbConnection"])
     end
     
@@ -45,5 +45,33 @@ describe ConnectionManager::SecondaryConnectionBuilder do
     end
     
   end
+  
+  context "cross database joins" do
+    ConnectionManager::Connections.initialize(:env => 'test')
+    
+    class Foo < ActiveRecord::Base
+      set_table_name_for_joins
+      belongs_to :user 
+    end
+    
+    class User < CmUserConnection
+      set_table_name_for_joins
+      has_many :foos
+    end
+    
+    before :all do
+      @user = User.new(:name => "Testing")
+      @user.save
+      @foo = Foo.new(:user_id => @user.id)
+      @foo.save
+    end
+    
+    it "should work" do
+      @user.foos.blank?.should be_false  
+      found = Foo.select('users.name AS user_name').joins(:user).where(:id => @foo.id).first
+      puts Foo.select('users.name AS user_name').joins(:user).where(:id => @foo.id).to_sql
+      found.user_name.blank?.should be_false
+    end
+  end 
 end
 

data/spec/mysql2_database.yml

@@ -4,14 +4,18 @@
 common: &common
   adapter: mysql2
   username: root
-  password: some_password
+  password: omegared
   pool: 100
   timeout: 5000
   
 test:
   <<: *common
   database: cm_test
- 
+  
+cm_user_test:
+  <<: *common
+  database: cm_user_test
+  
 slave_1_cm_test:
   <<: *common  
   database: cm_test

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: connection_manager
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.2.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-01-09 00:00:00.000000000Z
+date: 2012-01-11 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
-  requirement: &70350833047080 !ruby/object:Gem::Requirement
+  requirement: &70223799590600 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -21,10 +21,10 @@ dependencies:
         version: '3.0'
   type: :runtime
   prerelease: false
-  version_requirements: *70350833047080
+  version_requirements: *70223799590600
 - !ruby/object:Gem::Dependency
   name: sqlite3
-  requirement: &70350833046660 !ruby/object:Gem::Requirement
+  requirement: &70223799590180 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,10 +32,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70350833046660
+  version_requirements: *70223799590180
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &70350833046200 !ruby/object:Gem::Requirement
+  requirement: &70223799589720 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -43,10 +43,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70350833046200
+  version_requirements: *70223799589720
 - !ruby/object:Gem::Dependency
   name: autotest
-  requirement: &70350833045780 !ruby/object:Gem::Requirement
+  requirement: &70223799589300 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -54,10 +54,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70350833045780
+  version_requirements: *70223799589300
 - !ruby/object:Gem::Dependency
   name: mocha
-  requirement: &70350833045360 !ruby/object:Gem::Requirement
+  requirement: &70223799588880 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -65,10 +65,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70350833045360
+  version_requirements: *70223799588880
 - !ruby/object:Gem::Dependency
   name: factory_girl
-  requirement: &70350833044940 !ruby/object:Gem::Requirement
+  requirement: &70223799588460 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -76,10 +76,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70350833044940
+  version_requirements: *70223799588460
 - !ruby/object:Gem::Dependency
   name: mysql2
-  requirement: &70350833044520 !ruby/object:Gem::Requirement
+  requirement: &70223799588040 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -87,7 +87,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70350833044520
+  version_requirements: *70223799588040
 description: Simplifies connecting to Muliple and Replication databases with rails
   and active_record
 email:
@@ -108,6 +108,7 @@ files:
 - lib/connection_manager/associations.rb
 - lib/connection_manager/connection_manager_railtie.rb
 - lib/connection_manager/connections.rb
+- lib/connection_manager/cross_schema_patch.rb
 - lib/connection_manager/method_recorder.rb
 - lib/connection_manager/secondary_connection_builder.rb
 - lib/connection_manager/version.rb