composite_primary_keys 0.9.93 → 1.0.0

data/History.txt

@@ -1,3 +1,7 @@
+== 1.0.0 2008-06-05
+
+* Support for Rails 2.1
+
 == 0.9.93 2008-06-01
 
 * set fixed dependency on activerecord 2.0.2

data/Manifest.txt

@@ -11,6 +11,7 @@ lib/adapter_helper/oracle.rb
 lib/adapter_helper/postgresql.rb
 lib/adapter_helper/sqlite3.rb
 lib/composite_primary_keys.rb
+lib/composite_primary_keys/association_preload.rb
 lib/composite_primary_keys/associations.rb
 lib/composite_primary_keys/attribute_methods.rb
 lib/composite_primary_keys/base.rb

data/Rakefile

@@ -52,7 +52,7 @@ hoe = Hoe.new(GEM_NAME, VERS) do |p|
 
   # == Optional
   p.changes = p.paragraphs_of("History.txt", 0..1).join("\n\n")
-  p.extra_deps = [['activerecord', '= 2.0.2']]  #An array of rubygem dependencies.
+  p.extra_deps = [['activerecord', '>= 2.1.0']]  #An array of rubygem dependencies.
   #p.spec_extras    - A hash of extra values to set in the gemspec.
 end
 

data/lib/composite_primary_keys.rb

@@ -36,6 +36,7 @@ end
 require 'composite_primary_keys/fixtures'
 require 'composite_primary_keys/composite_arrays'
 require 'composite_primary_keys/associations'
+require 'composite_primary_keys/association_preload'
 require 'composite_primary_keys/reflection'
 require 'composite_primary_keys/base'
 require 'composite_primary_keys/calculations'

data/lib/composite_primary_keys/association_preload.rb

@@ -0,0 +1,220 @@
+module CompositePrimaryKeys
+  module ActiveRecord
+    module AssociationPreload
+      def self.append_features(base)
+        super
+        base.send(:extend, ClassMethods)
+      end
+      
+      # Composite key versions of Association functions
+      module ClassMethods    
+        def preload_has_and_belongs_to_many_association(records, reflection, preload_options={})
+          table_name = reflection.klass.quoted_table_name
+          id_to_record_map, ids = construct_id_map(records)
+          records.each {|record| record.send(reflection.name).loaded}
+          options = reflection.options
+
+          if(composite?)
+            primary_key = reflection.primary_key_name.to_s.split(CompositePrimaryKeys::ID_SEP)
+            where = (primary_key * ids.size).in_groups_of(primary_key.size).map do |keys|
+              "(" + keys.map{|key| "t0.#{key} = ?"}.join(" AND ") + ")"
+            end.join(" OR ")
+            
+            conditions = [where, ids].flatten
+            joins = "INNER JOIN #{connection.quote_table_name options[:join_table]} as t0 ON #{full_composite_join_clause(reflection.klass.quoted_table_name, reflection.klass.primary_key, 't0', reflection.association_foreign_key)}"
+            parent_primary_keys = reflection.primary_key_name.to_s.split(CompositePrimaryKeys::ID_SEP).map{|k| "t0.#{k}"}
+            parent_record_id = connection.concat(parent_primary_keys.zip(["','"] * (parent_primary_keys.size - 1)).flatten.compact)
+          else
+            conditions = ["t0.#{reflection.primary_key_name}  IN (?)", ids]
+            joins = "INNER JOIN #{connection.quote_table_name options[:join_table]} as t0 ON #{reflection.klass.quoted_table_name}.#{reflection.klass.primary_key} = t0.#{reflection.association_foreign_key}"
+            parent_record_id = reflection.primary_key_name
+          end
+          
+          conditions.first << append_conditions(options, preload_options)
+
+          associated_records = reflection.klass.find(:all, 
+            :conditions => conditions,
+            :include => options[:include],
+            :joins => joins,
+            :select => "#{options[:select] || table_name+'.*'}, #{parent_record_id} as _parent_record_id",
+            :order => options[:order])
+            
+          set_association_collection_records(id_to_record_map, reflection.name, associated_records, '_parent_record_id')
+        end
+                
+        def preload_has_many_association(records, reflection, preload_options={})
+          id_to_record_map, ids = construct_id_map(records)
+          records.each {|record| record.send(reflection.name).loaded}
+          options = reflection.options
+
+          if options[:through]
+            through_records = preload_through_records(records, reflection, options[:through])
+            through_reflection = reflections[options[:through]]
+            through_primary_key = through_reflection.primary_key_name
+            
+            unless through_records.empty?
+              source = reflection.source_reflection.name
+              #add conditions from reflection!
+              through_records.first.class.preload_associations(through_records, source, reflection.options)
+              through_records.each do |through_record|
+                add_preloaded_records_to_collection(id_to_record_map[through_record[through_primary_key].to_s], reflection.name, through_record.send(source))
+              end
+            end
+          else 
+            associated_records = find_associated_records(ids, reflection, preload_options)
+            set_association_collection_records(id_to_record_map, reflection.name, associated_records, reflection.primary_key_name.to_s.split(CompositePrimaryKeys::ID_SEP))
+          end
+        end
+
+        def preload_through_records(records, reflection, through_association)
+          through_reflection = reflections[through_association]
+          through_primary_key = through_reflection.primary_key_name
+
+          if reflection.options[:source_type]
+            interface = reflection.source_reflection.options[:foreign_type]
+            preload_options = {:conditions => ["#{connection.quote_column_name interface} = ?", reflection.options[:source_type]]}
+
+            records.compact!
+            records.first.class.preload_associations(records, through_association, preload_options)
+
+            # Dont cache the association - we would only be caching a subset
+            through_records = []
+            records.each do |record|
+              proxy = record.send(through_association)
+
+              if proxy.respond_to?(:target)
+                through_records << proxy.target
+                proxy.reset
+              else # this is a has_one :through reflection
+                through_records << proxy if proxy
+              end
+            end
+            through_records.flatten!
+          else
+            records.first.class.preload_associations(records, through_association)
+            through_records = records.map {|record| record.send(through_association)}.flatten
+          end
+          
+          through_records.compact!
+          through_records
+        end
+
+        def preload_belongs_to_association(records, reflection, preload_options={})
+          options = reflection.options
+          primary_key_name = reflection.primary_key_name.to_s.split(CompositePrimaryKeys::ID_SEP)
+
+          if options[:polymorphic]
+            raise AssociationNotSupported, "Polymorphic joins not supported for composite keys"
+          else
+            id_map = {}
+            records.each do |record|
+              key = primary_key_name.map{|k| record.send(k)}.join(CompositePrimaryKeys::ID_SEP)
+              if key
+                mapped_records = (id_map[key.to_s] ||= [])
+                mapped_records << record
+              end
+            end
+            klasses_and_ids = [[reflection.klass.name, id_map]]
+          end
+
+          klasses_and_ids.each do |klass_and_id|
+            klass_name, id_map = *klass_and_id
+            klass = klass_name.constantize
+            table_name = klass.quoted_table_name
+            
+            if(composite?)
+              primary_key = klass.primary_key.to_s.split(CompositePrimaryKeys::ID_SEP)
+              ids = id_map.keys.uniq.map {|id| id.to_s.split(CompositePrimaryKeys::ID_SEP)}
+
+              where = (primary_key * ids.size).in_groups_of(primary_key.size).map do |keys|
+                 "(" + keys.map{|key| "#{table_name}.#{key} = ?"}.join(" AND ") + ")"
+              end.join(" OR ")
+              
+              conditions = [where, ids].flatten
+            else
+              conditions = ["#{table_name}.#{primary_key} IN (?)", id_map.keys.uniq]
+            end
+                                  
+            conditions.first << append_conditions(options, preload_options)
+            
+            associated_records = klass.find(:all, :conditions => conditions,
+                                            :include => options[:include],
+                                            :select => options[:select],
+                                            :joins => options[:joins],
+                                            :order => options[:order])
+                                            
+            set_association_single_records(id_map, reflection.name, associated_records, primary_key)
+          end
+        end
+
+        def set_association_collection_records(id_to_record_map, reflection_name, associated_records, key)
+          associated_records.each do |associated_record|
+            associated_record_key = associated_record[key]
+            associated_record_key = associated_record_key.is_a?(Array) ? associated_record_key.join(CompositePrimaryKeys::ID_SEP) : associated_record_key.to_s
+            mapped_records = id_to_record_map[associated_record_key]
+            add_preloaded_records_to_collection(mapped_records, reflection_name, associated_record)
+          end
+        end
+        
+        def set_association_single_records(id_to_record_map, reflection_name, associated_records, key)
+          seen_keys = {}
+          associated_records.each do |associated_record|
+            associated_record_key = associated_record[key]
+            associated_record_key = associated_record_key.is_a?(Array) ? associated_record_key.join(CompositePrimaryKeys::ID_SEP) : associated_record_key.to_s
+            
+            #this is a has_one or belongs_to: there should only be one record.
+            #Unfortunately we can't (in portable way) ask the database for 'all records where foo_id in (x,y,z), but please
+            # only one row per distinct foo_id' so this where we enforce that
+            next if seen_keys[associated_record_key]
+            seen_keys[associated_record_key] = true
+            mapped_records = id_to_record_map[associated_record_key]
+            mapped_records.each do |mapped_record|
+              mapped_record.send("set_#{reflection_name}_target", associated_record)
+            end
+          end
+        end
+              
+        def find_associated_records(ids, reflection, preload_options)
+          options = reflection.options
+          table_name = reflection.klass.quoted_table_name
+
+          if interface = reflection.options[:as]
+            raise AssociationNotSupported, "Polymorphic joins not supported for composite keys"
+          else
+            foreign_key = reflection.primary_key_name
+            conditions = ["#{reflection.klass.quoted_table_name}.#{foreign_key} IN (?)", ids]
+            
+            if(composite?)
+              foreign_keys = foreign_key.to_s.split(CompositePrimaryKeys::ID_SEP)
+            
+            where = (foreign_keys * ids.size).in_groups_of(foreign_keys.size).map do |keys|
+              "(" + keys.map{|key| "#{reflection.klass.quoted_table_name}.#{key} = ?"}.join(" AND ") + ")"
+              end.join(" OR ")
+                
+              conditions = [where, ids].flatten
+          end
+          end
+  
+          conditions.first << append_conditions(options, preload_options)
+
+          reflection.klass.find(:all,
+                                :select => (preload_options[:select] || options[:select] || "#{table_name}.*"),
+                                :include => preload_options[:include] || options[:include],
+                                :conditions => conditions,
+                                :joins => options[:joins],
+                                :group => preload_options[:group] || options[:group],
+                                :order => preload_options[:order] || options[:order])
+        end        
+        
+        def full_composite_join_clause(table1, full_keys1, table2, full_keys2)
+          full_keys1 = full_keys1.split(CompositePrimaryKeys::ID_SEP) if full_keys1.is_a?(String)
+          full_keys2 = full_keys2.split(CompositePrimaryKeys::ID_SEP) if full_keys2.is_a?(String)
+          where_clause = [full_keys1, full_keys2].transpose.map do |key_pair|
+            "#{table1}.#{key_pair.first}=#{table2}.#{key_pair.last}"
+          end.join(" AND ")
+          "(#{where_clause})"
+        end
+      end
+    end
+  end
+end

data/lib/composite_primary_keys/associations.rb

@@ -362,7 +362,7 @@ module ActiveRecord::Associations
     end
   end
   
-  class HasManyThroughAssociation < AssociationProxy #:nodoc:
+  class HasManyThroughAssociation < HasManyAssociation #:nodoc:
     def construct_conditions
       conditions = if @reflection.through_reflection.options[:as]
           "#{@reflection.through_reflection.table_name}.#{@reflection.through_reflection.options[:as]}_id = #{@owner.quoted_id} " + 

data/lib/composite_primary_keys/base.rb

@@ -26,6 +26,7 @@ module CompositePrimaryKeys
             include CompositeInstanceMethods
                      
             include CompositePrimaryKeys::ActiveRecord::Associations
+            include CompositePrimaryKeys::ActiveRecord::AssociationPreload
             include CompositePrimaryKeys::ActiveRecord::Calculations
             include CompositePrimaryKeys::ActiveRecord::AttributeMethods
           EOV

data/lib/composite_primary_keys/connection_adapters/oracle_adapter.rb

@@ -6,6 +6,10 @@ module ActiveRecord
       def supports_count_distinct? #:nodoc:
         false
       end
+      
+      def concat(*columns)
+        "(#{columns.join('||')})"
+      end
     end
   end
 end

data/lib/composite_primary_keys/connection_adapters/sqlite3_adapter.rb

@@ -6,6 +6,10 @@ module ActiveRecord
       def supports_count_distinct? #:nodoc:
         false
       end
+      
+      def concat(*columns)
+        "(#{columns.join('||')})"
+      end
     end
   end
 end

data/lib/composite_primary_keys/version.rb

@@ -1,9 +1,8 @@
 module CompositePrimaryKeys
   module VERSION #:nodoc:
-    MAJOR = 0
-    MINOR = 9
-    TINY  = 93
-
+    MAJOR = 1
+    MINOR = 0
+    TINY  = 0
     STRING = [MAJOR, MINOR, TINY].join('.')
   end
 end

data/test/test_composite_arrays.rb

@@ -43,4 +43,9 @@ class CompositeArraysTest < Test::Unit::TestCase
     assert_equal CompositePrimaryKeys::CompositeIds, keys.class
     assert_equal '1,2,3', keys.to_s
   end
+  
+  def test_flatten
+    keys = [CompositePrimaryKeys::CompositeIds.new([1,2,3]), CompositePrimaryKeys::CompositeIds.new([4,5,6])]
+    assert_equal 6, keys.flatten.size
+  end
 end

data/website/index.html

@@ -33,7 +33,7 @@
     <h1>Composite Primary Keys</h1>
     <div id="version" class="clickable" onclick='document.location = "http://rubyforge.org/projects/compositekeys"; return false'>
       Get Version
-      <a href="http://rubyforge.org/projects/compositekeys" class="numbers">0.9.92</a>
+      <a href="http://rubyforge.org/projects/compositekeys" class="numbers">1.0.0</a>
     </div>
     <h1>&#x2192; Ruby on Rails</h1>
 
@@ -296,7 +296,7 @@ other stories and things.</p>
 
 	<p>Comments are welcome. Send an email to <a href="mailto:drnicwilliams@gmail.com">Dr Nic Williams</a>.</p>
     <p class="coda">
-      <a href="mailto:drnicwilliams@gmail.com">Dr Nic</a>, 5th March 2008<br>
+      <a href="mailto:drnicwilliams@gmail.com">Dr Nic</a>, 5th June 2008<br>
       Theme extended from <a href="http://rb2js.rubyforge.org/">Paul Battley</a>
     </p>
 </div>

data/website/version-raw.js

@@ -1,3 +1,3 @@
 // Announcement JS file
-var version = "0.9.92";
+var version = "1.0.0";
 MagicAnnouncement.show('compositekeys', version);

data/website/version.js

@@ -1,4 +1,4 @@
 // Version JS file
-var version = "0.9.92";
+var version = "1.0.0";
 
 document.write(" - " + version);

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: composite_primary_keys
 version: !ruby/object:Gem::Version 
-  version: 0.9.93
+  version: 1.0.0
 platform: ruby
 authors: 
 - Dr Nic Williams
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-06-04 00:00:00 -05:00
+date: 2008-06-05 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -17,9 +17,9 @@ dependencies:
   version_requirement: 
   version_requirements: !ruby/object:Gem::Requirement 
     requirements: 
-    - - "="
+    - - ">="
       - !ruby/object:Gem::Version 
-        version: 2.0.2
+        version: 2.1.0
     version: 
 description: Composite key support for ActiveRecords
 email: drnicwilliams@gmail.com
@@ -50,6 +50,7 @@ files:
 - lib/adapter_helper/postgresql.rb
 - lib/adapter_helper/sqlite3.rb
 - lib/composite_primary_keys.rb
+- lib/composite_primary_keys/association_preload.rb
 - lib/composite_primary_keys/associations.rb
 - lib/composite_primary_keys/attribute_methods.rb
 - lib/composite_primary_keys/base.rb
@@ -180,7 +181,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: compositekeys
-rubygems_version: 1.1.1
+rubygems_version: 1.0.1
 signing_key: 
 specification_version: 2
 summary: Composite key support for ActiveRecords