acts_as_partitionable 0.0.2 → 0.0.3

data/lib/acts_as_partitionable.rb

@@ -45,22 +45,28 @@ module Acts
             raise ::ActiveRecord::ConfigurationError.new
           end
         end
-
-        partition_db_klass ||= eval <<-TOS
-          class #{self.name}Partitionable#{partition_name} < #{self.name}
-            # setting abstract_class to true so that ActiveRecord doesn't look
-            # for a db table for this base model class
-            self.abstract_class = true
-            def self.find_every(options)
-              (options ||= {})[:readonly] = true if #{partition_db_klass_readonly}
-              super(options)
-            end
-            def self.readonly?; #{partition_db_klass_readonly}; end
-          end 
-          #{self.name}Partitionable#{partition_name}
-        TOS
-        partition_db_klass.establish_connection(db_config)
         
+        self_name = (self.name.include?('::') ? '' : '::') + self.name
+        partition_db_klass = ("#{self_name}Partitionable#{partition_name}".constantize rescue nil)
+
+        if partition_db_klass.nil?
+          partition_db_klass ||= eval <<-TOS
+            class #{self_name}Partitionable#{partition_name} < #{self_name}
+              # setting abstract_class to true so that ActiveRecord doesn't look
+              # for a db table for this base model class
+              self.abstract_class = true
+              def self.find_every(options)
+                (options ||= {})[:readonly] = true if #{partition_db_klass_readonly}
+                super(options)
+              end
+              def self.readonly?; #{partition_db_klass_readonly}; end
+            end 
+            #{self_name}Partitionable#{partition_name}
+          TOS
+
+          partition_db_klass.establish_connection(db_config)
+        end
+
         class_eval <<-PART_PROC_END    
         def self.#{partition_name}(&block)
           return #{partition_db_klass}.module_eval(&block) if block_given?

data/lib/connection_pool.rb

@@ -1,20 +1,24 @@
 # CONFIDENTIAL AND PROPRIETARY. © 2007 Revolution Health Group LLC. All rights reserved.
+
 module ActiveRecord
   class Base
     class << self
       alias_method :no_cp_remove_connection, :remove_connection
       alias_method :no_cp_establish_connection, :establish_connection
+      alias_method :no_cp_clear_active_connections!, :clear_active_connections!
             
       @@pooled_connections ||= {}
       def pooled_connections
         @@pooled_connections[Thread.current.object_id] ||= {}
       end
       
-      def close_all_connections
-        pooled_connections.each do | key, value | 
-          pooled_connections.delete(key)
-          active_connections.select { |klass, konn| no_cp_remove_connection(klass.constantize) if konn == value[:connection] } 
+      def clear_active_connections!
+        active_connections.each do |name, conn|
+          conn_key = nil
+          pooled_connections.each { |key, value| conn_key = key if value != nil && value[:connection] == conn }
+          pooled_connections.delete(conn_key) if not conn_key.nil?
         end
+        no_cp_clear_active_connections!
       end
       
       def remove_connection(klass=self)
@@ -34,15 +38,38 @@ module ActiveRecord
         no_cp_remove_connection(klass)
       end # remove_connection
       
-      def establish_connection(spec = nil)
-        if spec != nil and spec.kind_of?(ActiveRecord::Base::ConnectionSpecification)
-          @partitionable_adapter_methods ||= []
-          if not @partitionable_adapter_methods.include?(spec.adapter_method.to_s)
-            @partitionable_adapter_methods << (spec.adapter_method.to_s)
-            
-            self.class_eval <<-REUSE_END
+      def establish_connection(spec = nil)       
+        pool_connection(spec) if spec != nil and spec.kind_of?(ActiveRecord::Base::ConnectionSpecification)
+        no_cp_establish_connection(spec)
+      end # establish_connection
+      
+      
+      # closing all is pretty final, you don't want to do this unless you are really all done
+      def close_all_connections
+        ar_konn = nil
+        pooled_connections.each do | key, value | 
+          pooled_connections.delete(key)
+          active_connections.select do |klass, konn| 
+            if konn == value[:connection] 
+              result = no_cp_remove_connection(klass.constantize) 
+              ar_konn = result if klass.constantize == ActiveRecord::Base
+            end
+          end 
+        end
+        ar_konn
+      end
+      
+      private
+      def pool_connection(spec)
+        @partitionable_adapter_methods ||= []
+
+        if not @partitionable_adapter_methods.include?(spec.adapter_method.to_s)
+          @partitionable_adapter_methods << (spec.adapter_method.to_s)
+
+          if not ActiveRecord::Base.methods.include?("ar_#{spec.adapter_method}")
+            ActiveRecord::Base.class_eval <<-REUSE_END
               class << self
-                alias_method :ar_#{spec.adapter_method}, :#{spec.adapter_method}
+                alias_method :ar_#{spec.adapter_method}, :#{spec.adapter_method} 
               end
               def self.#{spec.adapter_method}(config)
                 conn_key = config.to_s
@@ -54,11 +81,16 @@ module ActiveRecord
                 pooled_connections[conn_key][:connection] rescue nil
               end
             REUSE_END
-          end
-        end
-        no_cp_establish_connection(spec)
-      end # establish_connection
-	  end
+          end # if not method included
+        end # if not adapter included
+      end # pool_connection
+     
+      
+      def reset_ref_counts
+        ActiveRecord::Base.pooled_connections.each {| key, value | value[:count] = 1 }
+      end # reset_ref_counts
+      
+	  end # self
   end # Pool
 end # Connection
 

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.0
 specification_version: 1
 name: acts_as_partitionable
 version: !ruby/object:Gem::Version 
-  version: 0.0.2
-date: 2007-04-20 00:00:00 -04:00
+  version: 0.0.3
+date: 2007-04-24 00:00:00 -04:00
 summary: acts_as_partitionable allows one to use multiple DBs to partition data for models
 require_paths: 
 - lib