composite_primary_keys 1.0.8 → 1.0.10

data/History.txt

@@ -1,3 +1,13 @@
+== 1.0.10 2008-10-22
+
+* add composite key where clause creator method [timurv]
+
+== 1.0.9 2008-09-08
+
+* fix postgres tests
+* fix for delete_records when has_many association has composite keys [darxriggs]
+* more consistent table/column name quoting [pbrant]
+
 == 1.0.8 2008-08-27
 
 * fix has_many :through for non composite models [thx rcarver]

data/lib/composite_primary_keys/association_preload.rb

@@ -5,43 +5,43 @@ module CompositePrimaryKeys
         super
         base.send(:extend, ClassMethods)
       end
-      
+
       # Composite key versions of Association functions
-      module ClassMethods    
+      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?)
+          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 ") + ")"
+              "(" + keys.map{|key| "t0.#{connection.quote_column_name(key)} = ?"}.join(" AND ") + ")"
             end.join(" OR ")
-            
+
             conditions = [where, ids].flatten
-            joins = "INNER JOIN #{connection.quote_table_name options[:join_table]} 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)
+            joins = "INNER JOIN #{connection.quote_table_name options[:join_table]} t0 ON #{full_composite_join_clause(reflection, reflection.klass.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.#{connection.quote_column_name(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]} t0 ON #{reflection.klass.quoted_table_name}.#{reflection.klass.primary_key} = t0.#{reflection.association_foreign_key}"
+            conditions = ["t0.#{connection.quote_column_name(reflection.primary_key_name)}  IN (?)", ids]
+            joins = "INNER JOIN #{connection.quote_table_name options[:join_table]} t0 ON #{reflection.klass.quoted_table_name}.#{connection.quote_column_name(reflection.klass.primary_key)} = t0.#{connection.quote_column_name(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, 
+          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])
-            
+            :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}
@@ -51,7 +51,7 @@ module CompositePrimaryKeys
             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!
@@ -61,7 +61,7 @@ module CompositePrimaryKeys
                 add_preloaded_records_to_collection(id_to_record_map[key], reflection.name, through_record.send(source))
               end
             end
-          else 
+          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
@@ -95,7 +95,7 @@ module CompositePrimaryKeys
             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
@@ -107,23 +107,23 @@ module CompositePrimaryKeys
           if options[:polymorphic]
             raise AssociationNotSupported, "Polymorphic joins not supported for composite keys"
           else
-          	# I need to keep the original ids for each record (as opposed to the stringified) so
-          	# that they get properly converted for each db so the id_map ends up looking like:
-          	#
-          	# { '1,2' => {:id => [1,2], :records => [...records...]}}
+            # I need to keep the original ids for each record (as opposed to the stringified) so
+            # that they get properly converted for each db so the id_map ends up looking like:
+            #
+            # { '1,2' => {:id => [1,2], :records => [...records...]}}
             id_map = {}
-            
+
             records.each do |record|
               key = primary_key_name.map{|k| record.send(k)}
               key_as_string = key.join(CompositePrimaryKeys::ID_SEP)
-              
+
               if key_as_string
                 mapped_records = (id_map[key_as_string] ||= {:id => key, :records => []})
                 mapped_records[:records] << record
               end
             end
-            
-            
+
+
             klasses_and_ids = [[reflection.klass.name, id_map]]
           end
 
@@ -131,28 +131,30 @@ module CompositePrimaryKeys
             klass_name, id_map = *klass_and_id
             klass = klass_name.constantize
             table_name = klass.quoted_table_name
-            
-            if(composite?)
+            connection = reflection.active_record.connection
+
+            if composite?
               primary_key = klass.primary_key.to_s.split(CompositePrimaryKeys::ID_SEP)
               ids = id_map.keys.uniq.map {|id| id_map[id][:id]}
 
               where = (primary_key * ids.size).in_groups_of(primary_key.size).map do |keys|
-                 "(" + keys.map{|key| "#{table_name}.#{key} = ?"}.join(" AND ") + ")"
+                 "(" + keys.map{|key| "#{table_name}.#{connection.quote_column_name(key)} = ?"}.join(" AND ") + ")"
               end.join(" OR ")
-              
+
               conditions = [where, ids].flatten
             else
-              conditions = ["#{table_name}.#{primary_key} IN (?)", id_map.keys.uniq]
+              conditions = ["#{table_name}.#{connection.quote_column_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])
-                                            
+
+            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
@@ -165,13 +167,13 @@ module CompositePrimaryKeys
             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
@@ -183,7 +185,7 @@ module CompositePrimaryKeys
             end
           end
         end
-              
+
         def find_associated_records(ids, reflection, preload_options)
           options = reflection.options
           table_name = reflection.klass.quoted_table_name
@@ -191,40 +193,44 @@ module CompositePrimaryKeys
           if interface = reflection.options[:as]
             raise AssociationNotSupported, "Polymorphic joins not supported for composite keys"
           else
+            connection = reflection.active_record.connection
             foreign_key = reflection.primary_key_name
-            conditions = ["#{reflection.klass.quoted_table_name}.#{foreign_key} IN (?)", ids]
+            conditions = ["#{table_name}.#{connection.quote_column_name(foreign_key)} IN (?)", ids]
             
-            if(composite?)
+            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 ") + ")"
+              where = (foreign_keys * ids.size).in_groups_of(foreign_keys.size).map do |keys|
+                "(" + keys.map{|key| "#{table_name}.#{connection.quote_column_name(key)} = ?"}.join(" AND ") + ")"
               end.join(" OR ")
-                
+
               conditions = [where, ids].flatten
+            end
           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])
+            :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)
+        def full_composite_join_clause(reflection, table1, full_keys1, table2, full_keys2)
+          connection = reflection.active_record.connection
           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}"
+            quoted1 = connection.quote_table_name(table1)
+            quoted2 = connection.quote_table_name(table2)
+            "#{quoted1}.#{connection.quote_column_name(key_pair.first)}=#{quoted2}.#{connection.quote_column_name(key_pair.last)}"
           end.join(" AND ")
           "(#{where_clause})"
         end
       end
     end
   end
-end
+end

data/lib/composite_primary_keys/associations.rb

@@ -1,409 +1,428 @@
-module CompositePrimaryKeys
-  module ActiveRecord
-    module Associations
-      def self.append_features(base)
-        super
-        base.send(:extend, ClassMethods)
-      end
-      
-      # Composite key versions of Association functions
-      module ClassMethods
-        
-        def construct_counter_sql_with_included_associations(options, join_dependency)
-          scope = scope(:find)
-          sql = "SELECT COUNT(DISTINCT #{quoted_table_columns(primary_key)})"
-          
-          # A (slower) workaround if we're using a backend, like sqlite, that doesn't support COUNT DISTINCT.
-          if !self.connection.supports_count_distinct?
-            sql = "SELECT COUNT(*) FROM (SELECT DISTINCT #{quoted_table_columns(primary_key)}"
-          end
-          
-          sql << " FROM #{table_name} "
-          sql << join_dependency.join_associations.collect{|join| join.association_join }.join
-          
-          add_joins!(sql, options, scope)
-          add_conditions!(sql, options[:conditions], scope)
-          add_limited_ids_condition!(sql, options, join_dependency) if !using_limitable_reflections?(join_dependency.reflections) && ((scope && scope[:limit]) || options[:limit])
-
-          add_limit!(sql, options, scope) if using_limitable_reflections?(join_dependency.reflections)
-
-          if !self.connection.supports_count_distinct?
-            sql << ")"
-          end
-
-          return sanitize_sql(sql)          
-        end
-
-        def construct_finder_sql_with_included_associations(options, join_dependency)
-          scope = scope(:find)
-          sql = "SELECT #{column_aliases(join_dependency)} FROM #{(scope && scope[:from]) || options[:from] || table_name} "
-          sql << join_dependency.join_associations.collect{|join| join.association_join }.join
- 
-          add_joins!(sql, options, scope)
-          add_conditions!(sql, options[:conditions], scope)
-          add_limited_ids_condition!(sql, options, join_dependency) if !using_limitable_reflections?(join_dependency.reflections) && options[:limit]
-
-          sql << "ORDER BY #{options[:order]} " if options[:order]
- 
-          add_limit!(sql, options, scope) if using_limitable_reflections?(join_dependency.reflections)
- 
-          return sanitize_sql(sql)
-        end
-        
-        def table_columns(columns)
-          columns.collect {|column| "#{self.table_name}.#{column}"}
-        end
-        
-        def quoted_table_columns(columns)
-          table_columns(columns).join(ID_SEP)
-        end
-        
-      end
-      
-    end
-  end
-end
-
-module ActiveRecord::Associations::ClassMethods
-  class JoinDependency
-    def construct_association(record, join, row)
-      case join.reflection.macro
-        when :has_many, :has_and_belongs_to_many
-          collection = record.send(join.reflection.name)
-          collection.loaded
-
-          join_aliased_primary_keys = join.active_record.composite? ? 
-            join.aliased_primary_key : [join.aliased_primary_key]
-          return nil if 
-            record.id.to_s != join.parent.record_id(row).to_s or not
-            join_aliased_primary_keys.select {|key| row[key].nil?}.blank?
-          association = join.instantiate(row)
-          collection.target.push(association) unless collection.target.include?(association)
-        when :has_one, :belongs_to
-          return if record.id.to_s != join.parent.record_id(row).to_s or
-                    join.aliased_primary_key.to_a.any? { |key| row[key].nil? }
-          association = join.instantiate(row)
-          record.send("set_#{join.reflection.name}_target", association)
-        else
-          raise ConfigurationError, "unknown macro: #{join.reflection.macro}"
-      end
-      return association
-    end
-    
-    class JoinBase
-      def aliased_primary_key
-        active_record.composite? ? 
-          primary_key.inject([]) {|aliased_keys, key| aliased_keys << "#{ aliased_prefix }_r#{aliased_keys.length}"} : 
-          "#{ aliased_prefix }_r0"
-      end
-
-      def record_id(row)
-        active_record.composite? ?
-          aliased_primary_key.map {|key| row[key]}.to_composite_ids :
-          row[aliased_primary_key]
-      end
-
-      def column_names_with_alias
-        unless @column_names_with_alias
-          @column_names_with_alias = []
-          keys = active_record.composite? ? primary_key.map(&:to_s) : [primary_key]
-          (keys + (column_names - keys)).each_with_index do |column_name, i|
-            @column_names_with_alias << [column_name, "#{ aliased_prefix }_r#{ i }"]
-          end
-        end
-        return @column_names_with_alias
-      end
-    end
-    
-    class JoinAssociation < JoinBase
-      alias single_association_join association_join
-      def association_join
-        reflection.active_record.composite? ?
-          composite_association_join :
-          single_association_join
-      end
-      
-      def composite_association_join
-        join = case reflection.macro
-          when :has_and_belongs_to_many
-            " LEFT OUTER JOIN %s ON %s " % [
-              table_alias_for(options[:join_table], aliased_join_table_name),
-                composite_join_clause(
-                  full_keys(aliased_join_table_name, options[:foreign_key] || reflection.active_record.to_s.classify.foreign_key),
-                  full_keys(reflection.active_record.table_name, reflection.active_record.primary_key)
-                )
-              ] +
-             " LEFT OUTER JOIN %s ON %s " % [
-                table_name_and_alias,
-                composite_join_clause(
-                  full_keys(aliased_table_name, klass.primary_key),
-                  full_keys(aliased_join_table_name, options[:association_foreign_key] || klass.table_name.classify.foreign_key)
-                )
-              ]
-          when :has_many, :has_one
-            case
-              when reflection.macro == :has_many && reflection.options[:through]
-                through_conditions = through_reflection.options[:conditions] ? "AND #{interpolate_sql(sanitize_sql(through_reflection.options[:conditions]))}" : ''
-                if through_reflection.options[:as] # has_many :through against a polymorphic join
-                  raise AssociationNotSupported, "Polymorphic joins not supported for composite keys"
-                else
-                  if source_reflection.macro == :has_many && source_reflection.options[:as]
-                    raise AssociationNotSupported, "Polymorphic joins not supported for composite keys"
-                  else
-                    case source_reflection.macro
-                      when :belongs_to
-                        first_key  = primary_key
-                        second_key = options[:foreign_key] || klass.to_s.classify.foreign_key
-                      when :has_many
-                        first_key  = through_reflection.klass.to_s.classify.foreign_key
-                        second_key = options[:foreign_key] || primary_key
-                    end
-                    
-                    " LEFT OUTER JOIN %s ON %s "  % [
-                      table_alias_for(through_reflection.klass.table_name, aliased_join_table_name), 
-                       composite_join_clause(
-                         full_keys(aliased_join_table_name, through_reflection.primary_key_name),
-                         full_keys(parent.aliased_table_name, parent.primary_key)
-                       )
-                     ] +
-                     " LEFT OUTER JOIN %s ON %s " % [
-                       table_name_and_alias,
-                       composite_join_clause(
-                         full_keys(aliased_table_name, first_key), 
-                         full_keys(aliased_join_table_name, second_key)
-                       )
-                    ]
-                  end
-                end
-              
-              when reflection.macro == :has_many && reflection.options[:as]
-                raise AssociationNotSupported, "Polymorphic joins not supported for composite keys"
-              when reflection.macro == :has_one && reflection.options[:as]
-                raise AssociationNotSupported, "Polymorphic joins not supported for composite keys"
-              else
-                foreign_key = options[:foreign_key] || reflection.active_record.name.foreign_key
-                " LEFT OUTER JOIN %s ON %s " % [
-                  table_name_and_alias,
-                  composite_join_clause(
-                    full_keys(aliased_table_name, foreign_key), 
-                    full_keys(parent.aliased_table_name, parent.primary_key)),
-                ]
-            end
-          when :belongs_to
-            " LEFT OUTER JOIN %s ON %s " % [
-               table_name_and_alias, 
-               composite_join_clause(
-                 full_keys(aliased_table_name, reflection.klass.primary_key), 
-                 full_keys(parent.aliased_table_name, options[:foreign_key] || klass.to_s.foreign_key)),
-              ]
-          else
-            ""
-        end || ''
-        join << %(AND %s.%s = %s ) % [
-          aliased_table_name, 
-          reflection.active_record.connection.quote_column_name(reflection.active_record.inheritance_column), 
-          klass.connection.quote(klass.name)] unless klass.descends_from_active_record?
-        join << "AND #{interpolate_sql(sanitize_sql(reflection.options[:conditions]))} " if reflection.options[:conditions]
-        join
-      end
-      
-      def full_keys(table_name, keys)
-        keys.is_a?(Array) ? keys.collect {|key| "#{table_name}.#{key}"}.join(CompositePrimaryKeys::ID_SEP) : "#{table_name}.#{keys}"
-      end
-
-      def composite_join_clause(full_keys1, 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|
-          "#{key_pair.first}=#{key_pair.last}"
-        end.join(" AND ")
-        "(#{where_clause})"
-      end
-    end
-  end
-end
-
-module ActiveRecord::Associations
-  class AssociationProxy #:nodoc:
-    
-    def composite_where_clause(full_keys, ids)
-      full_keys = full_keys.split(CompositePrimaryKeys::ID_SEP) if full_keys.is_a?(String)
-      
-      if ids.is_a?(String)
-        ids = [[ids]]
-      elsif not ids.first.is_a?(Array) # if single comp key passed, turn into an array of 1
-        ids = [ids.to_composite_ids]
-      end
-      
-      where_clause = ids.map do |id_set|
-        transposed = id_set.size == 1 ? [[full_keys, id_set.first]] : [full_keys, id_set].transpose
-        transposed.map do |full_key, id|
-          "#{full_key.to_s}=#{@reflection.klass.sanitize(id)}"
-        end.join(" AND ")
-      end.join(") OR (")
-      
-      "(#{where_clause})"
-    end
-
-    def composite_join_clause(full_keys1, 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|
-        "#{key_pair.first}=#{key_pair.last}"
-      end.join(" AND ")
-      
-      "(#{where_clause})"
-    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
-    
-    def full_keys(table_name, keys)
-      keys = keys.split(CompositePrimaryKeys::ID_SEP) if keys.is_a?(String)
-      keys.is_a?(Array) ? keys.collect {|key| "#{table_name}.#{key}"}.join(CompositePrimaryKeys::ID_SEP) : "#{table_name}.#{keys}"
-    end
-    
-    def full_columns_equals(table_name, keys, quoted_ids)
-      if keys.is_a?(Symbol) or (keys.is_a?(String) and keys == keys.to_s.split(CompositePrimaryKeys::ID_SEP))
-        return "#{table_name}.#{keys} = #{quoted_ids}"
-      end
-      keys = keys.split(CompositePrimaryKeys::ID_SEP) if keys.is_a?(String)
-      quoted_ids = quoted_ids.split(CompositePrimaryKeys::ID_SEP) if quoted_ids.is_a?(String)
-      keys_ids = [keys, quoted_ids].transpose
-      keys_ids.collect {|key, id| "(#{table_name}.#{key} = #{id})"}.join(' AND ')
-    end 
-
-    def set_belongs_to_association_for(record)
-      if @reflection.options[:as]
-        record["#{@reflection.options[:as]}_id"]   = @owner.id unless @owner.new_record?
-        record["#{@reflection.options[:as]}_type"] = @owner.class.base_class.name.to_s
-      else
-        key_values = @reflection.primary_key_name.to_s.split(CompositePrimaryKeys::ID_SEP).zip([@owner.id].flatten)
-        key_values.each{|kv| record[kv.first] = kv.last} unless @owner.new_record?
-      end    
-    end    
-  end
-
-  class HasAndBelongsToManyAssociation < AssociationCollection #:nodoc:
-    def construct_sql
-      interpolate_sql_options!(@reflection.options, :finder_sql)
-
-      if @reflection.options[:finder_sql]
-        @finder_sql = @reflection.options[:finder_sql]
-      else
-        @finder_sql = full_columns_equals(@reflection.options[:join_table], @reflection.primary_key_name, @owner.quoted_id)
-        @finder_sql << " AND (#{conditions})" if conditions
-      end
-
-      @join_sql = "INNER JOIN #{@reflection.options[:join_table]} ON " +
-      full_composite_join_clause(@reflection.klass.table_name, @reflection.klass.primary_key, @reflection.options[:join_table], @reflection.association_foreign_key)
-    end    
-  end
-  
-  class HasManyAssociation < AssociationCollection #:nodoc:
-    def construct_sql
-      case
-        when @reflection.options[:finder_sql]
-          @finder_sql = interpolate_sql(@reflection.options[:finder_sql])
-
-        when @reflection.options[:as]
-          @finder_sql = 
-            "#{@reflection.klass.table_name}.#{@reflection.options[:as]}_id = #{@owner.quoted_id} AND " + 
-            "#{@reflection.klass.table_name}.#{@reflection.options[:as]}_type = #{@owner.class.quote_value(@owner.class.base_class.name.to_s)}"
-          @finder_sql << " AND (#{conditions})" if conditions
-            
-        else
-          @finder_sql = full_columns_equals(@reflection.klass.table_name, @reflection.primary_key_name, @owner.quoted_id)
-          @finder_sql << " AND (#{conditions})" if conditions
-      end
-
-      if @reflection.options[:counter_sql]
-        @counter_sql = interpolate_sql(@reflection.options[:counter_sql])
-      elsif @reflection.options[:finder_sql]
-        # replace the SELECT clause with COUNT(*), preserving any hints within /* ... */
-        @reflection.options[:counter_sql] = @reflection.options[:finder_sql].sub(/SELECT (\/\*.*?\*\/ )?(.*)\bFROM\b/im) { "SELECT #{$1}COUNT(*) FROM" }
-        @counter_sql = interpolate_sql(@reflection.options[:counter_sql])
-      else
-        @counter_sql = @finder_sql
-      end
-    end
-    
-	def delete_records(records)
-	  if @reflection.options[:dependent]
-		records.each { |r| r.destroy }
-	  else
-		field_names = @reflection.primary_key_name.split(',')
-		field_names.collect! {|n| n + " = NULL"}
-		records.each do |r|
-		  where_class = nil
-		  
-		  if r.quoted_id.include?(',')
-		    where_class = [@reflection.klass.primary_key, r.quoted_id].transpose.map {|pair| "(#{pair[0]} = #{pair[1]})"}.join(" AND ")
-		  else
-		    where_class = @reflection.klass.primary_key + ' = ' +  r.quoted_id
-		  end
-		  
-		  @reflection.klass.update_all(  field_names.join(',') , where_class)
-		end
-	  end
-	end
-  end
-  
-  class HasOneAssociation < BelongsToAssociation #:nodoc:
-    def construct_sql
-      case
-        when @reflection.options[:as]
-          @finder_sql = 
-            "#{@reflection.klass.table_name}.#{@reflection.options[:as]}_id = #{@owner.quoted_id} AND " + 
-            "#{@reflection.klass.table_name}.#{@reflection.options[:as]}_type = #{@owner.class.quote_value(@owner.class.base_class.name.to_s)}"          
-        else
-          @finder_sql = full_columns_equals(@reflection.klass.table_name, @reflection.primary_key_name, @owner.quoted_id)
-      end
-      
-      @finder_sql << " AND (#{conditions})" if conditions
-    end
-  end
-  
-  class HasManyThroughAssociation < HasManyAssociation #:nodoc:
-    def construct_conditions_with_composite_keys
-      if @reflection.through_reflection.options[:as]
-        construct_conditions_without_composite_keys;
-      else
-        conditions = full_columns_equals(@reflection.through_reflection.table_name, @reflection.through_reflection.primary_key_name, @owner.quoted_id)
-        conditions << " AND (#{sql_conditions})" if sql_conditions
-        conditions
-      end
-    end
-    alias_method_chain :construct_conditions, :composite_keys
-    
-    def construct_joins_with_composite_keys(custom_joins = nil)
-      if @reflection.through_reflection.options[:as] || @reflection.source_reflection.options[:as]
-        construct_joins_without_composite_keys(custom_joins)
-      else
-        if @reflection.source_reflection.macro == :belongs_to
-          reflection_primary_key = @reflection.klass.primary_key
-          source_primary_key     = @reflection.source_reflection.primary_key_name
-        else
-          reflection_primary_key = @reflection.source_reflection.primary_key_name
-          source_primary_key     = @reflection.klass.primary_key
-        end
-
-        "INNER JOIN %s ON %s #{@reflection.options[:joins]} #{custom_joins}" % [
-          @reflection.through_reflection.table_name,
-          composite_join_clause(full_keys(@reflection.table_name, reflection_primary_key), full_keys(@reflection.through_reflection.table_name, source_primary_key))
-        ]
-      end
-    end
-    alias_method_chain :construct_joins, :composite_keys    
-  end
-  
-end
+module CompositePrimaryKeys
+  module ActiveRecord
+    module Associations
+      def self.append_features(base)
+        super
+        base.send(:extend, ClassMethods)
+      end
+
+      # Composite key versions of Association functions
+      module ClassMethods
+
+        def construct_counter_sql_with_included_associations(options, join_dependency)
+          scope = scope(:find)
+          sql = "SELECT COUNT(DISTINCT #{quoted_table_columns(primary_key)})"
+
+          # A (slower) workaround if we're using a backend, like sqlite, that doesn't support COUNT DISTINCT.
+          if !self.connection.supports_count_distinct?
+            sql = "SELECT COUNT(*) FROM (SELECT DISTINCT #{quoted_table_columns(primary_key)}"
+          end
+          
+          sql << " FROM #{quoted_table_name} "
+          sql << join_dependency.join_associations.collect{|join| join.association_join }.join
+
+          add_joins!(sql, options, scope)
+          add_conditions!(sql, options[:conditions], scope)
+          add_limited_ids_condition!(sql, options, join_dependency) if !using_limitable_reflections?(join_dependency.reflections) && ((scope && scope[:limit]) || options[:limit])
+
+          add_limit!(sql, options, scope) if using_limitable_reflections?(join_dependency.reflections)
+
+          if !self.connection.supports_count_distinct?
+            sql << ")"
+          end
+
+          return sanitize_sql(sql)
+        end
+
+        def construct_finder_sql_with_included_associations(options, join_dependency)
+          scope = scope(:find)
+          sql = "SELECT #{column_aliases(join_dependency)} FROM #{(scope && scope[:from]) || options[:from] || quoted_table_name} "
+          sql << join_dependency.join_associations.collect{|join| join.association_join }.join
+
+          add_joins!(sql, options, scope)
+          add_conditions!(sql, options[:conditions], scope)
+          add_limited_ids_condition!(sql, options, join_dependency) if !using_limitable_reflections?(join_dependency.reflections) && options[:limit]
+
+          sql << "ORDER BY #{options[:order]} " if options[:order]
+
+          add_limit!(sql, options, scope) if using_limitable_reflections?(join_dependency.reflections)
+
+          return sanitize_sql(sql)
+        end
+
+        def table_columns(columns)
+          columns.collect {|column| "#{self.quoted_table_name}.#{connection.quote_column_name(column)}"}
+        end
+
+        def quoted_table_columns(columns)
+          table_columns(columns).join(ID_SEP)
+        end
+
+      end
+
+    end
+  end
+end
+
+module ActiveRecord::Associations::ClassMethods
+  class JoinDependency
+    def construct_association(record, join, row)
+      case join.reflection.macro
+        when :has_many, :has_and_belongs_to_many
+          collection = record.send(join.reflection.name)
+          collection.loaded
+
+          join_aliased_primary_keys = join.active_record.composite? ?
+            join.aliased_primary_key : [join.aliased_primary_key]
+          return nil if
+            record.id.to_s != join.parent.record_id(row).to_s or not
+            join_aliased_primary_keys.select {|key| row[key].nil?}.blank?
+          association = join.instantiate(row)
+          collection.target.push(association) unless collection.target.include?(association)
+        when :has_one, :belongs_to
+          return if record.id.to_s != join.parent.record_id(row).to_s or
+                    [*join.aliased_primary_key].any? { |key| row[key].nil? }
+          association = join.instantiate(row)
+          record.send("set_#{join.reflection.name}_target", association)
+        else
+          raise ConfigurationError, "unknown macro: #{join.reflection.macro}"
+      end
+      return association
+    end
+
+    class JoinBase
+      def aliased_primary_key
+        active_record.composite? ?
+          primary_key.inject([]) {|aliased_keys, key| aliased_keys << "#{ aliased_prefix }_r#{aliased_keys.length}"} :
+          "#{ aliased_prefix }_r0"
+      end
+
+      def record_id(row)
+        active_record.composite? ?
+          aliased_primary_key.map {|key| row[key]}.to_composite_ids :
+          row[aliased_primary_key]
+      end
+
+      def column_names_with_alias
+        unless @column_names_with_alias
+          @column_names_with_alias = []
+          keys = active_record.composite? ? primary_key.map(&:to_s) : [primary_key]
+          (keys + (column_names - keys)).each_with_index do |column_name, i|
+            @column_names_with_alias << [column_name, "#{ aliased_prefix }_r#{ i }"]
+          end
+        end
+        return @column_names_with_alias
+      end
+    end
+
+    class JoinAssociation < JoinBase
+      alias single_association_join association_join
+      def association_join
+        reflection.active_record.composite? ? composite_association_join : single_association_join
+      end
+
+      def composite_association_join
+        join = case reflection.macro
+          when :has_and_belongs_to_many
+            " LEFT OUTER JOIN %s ON %s " % [
+              table_alias_for(options[:join_table], aliased_join_table_name),
+                composite_join_clause(
+                  full_keys(aliased_join_table_name, options[:foreign_key] || reflection.active_record.to_s.classify.foreign_key),
+                  full_keys(reflection.active_record.table_name, reflection.active_record.primary_key)
+                )
+              ] +
+             " LEFT OUTER JOIN %s ON %s " % [
+                table_name_and_alias,
+                composite_join_clause(
+                  full_keys(aliased_table_name, klass.primary_key),
+                  full_keys(aliased_join_table_name, options[:association_foreign_key] || klass.table_name.classify.foreign_key)
+                )
+              ]
+          when :has_many, :has_one
+            case
+              when reflection.macro == :has_many && reflection.options[:through]
+                through_conditions = through_reflection.options[:conditions] ? "AND #{interpolate_sql(sanitize_sql(through_reflection.options[:conditions]))}" : ''
+                if through_reflection.options[:as] # has_many :through against a polymorphic join
+                  raise AssociationNotSupported, "Polymorphic joins not supported for composite keys"
+                else
+                  if source_reflection.macro == :has_many && source_reflection.options[:as]
+                    raise AssociationNotSupported, "Polymorphic joins not supported for composite keys"
+                  else
+                    case source_reflection.macro
+                      when :belongs_to
+                        first_key  = primary_key
+                        second_key = options[:foreign_key] || klass.to_s.classify.foreign_key
+                      when :has_many
+                        first_key  = through_reflection.klass.to_s.classify.foreign_key
+                        second_key = options[:foreign_key] || primary_key
+                    end
+
+                    " LEFT OUTER JOIN %s ON %s "  % [
+                      table_alias_for(through_reflection.klass.table_name, aliased_join_table_name),
+                       composite_join_clause(
+                         full_keys(aliased_join_table_name, through_reflection.primary_key_name),
+                         full_keys(parent.aliased_table_name, parent.primary_key)
+                       )
+                     ] +
+                     " LEFT OUTER JOIN %s ON %s " % [
+                       table_name_and_alias,
+                       composite_join_clause(
+                         full_keys(aliased_table_name, first_key),
+                         full_keys(aliased_join_table_name, second_key)
+                       )
+                    ]
+                  end
+                end
+
+              when reflection.macro == :has_many && reflection.options[:as]
+                raise AssociationNotSupported, "Polymorphic joins not supported for composite keys"
+              when reflection.macro == :has_one && reflection.options[:as]
+                raise AssociationNotSupported, "Polymorphic joins not supported for composite keys"
+              else
+                foreign_key = options[:foreign_key] || reflection.active_record.name.foreign_key
+                " LEFT OUTER JOIN %s ON %s " % [
+                  table_name_and_alias,
+                  composite_join_clause(
+                    full_keys(aliased_table_name, foreign_key),
+                    full_keys(parent.aliased_table_name, parent.primary_key)),
+                ]
+            end
+          when :belongs_to
+            " LEFT OUTER JOIN %s ON %s " % [
+               table_name_and_alias,
+               composite_join_clause(
+                 full_keys(aliased_table_name, reflection.klass.primary_key),
+                 full_keys(parent.aliased_table_name, options[:foreign_key] || klass.to_s.foreign_key)),
+              ]
+          else
+            ""
+        end || ''
+        join << %(AND %s.%s = %s ) % [
+          aliased_table_name,
+          reflection.active_record.connection.quote_column_name(reflection.active_record.inheritance_column),
+          klass.connection.quote(klass.name)] unless klass.descends_from_active_record?
+        join << "AND #{interpolate_sql(sanitize_sql(reflection.options[:conditions]))} " if reflection.options[:conditions]
+        join
+      end
+
+      def full_keys(table_name, keys)
+        connection = reflection.active_record.connection
+        quoted_table_name = connection.quote_table_name(table_name)
+        if keys.is_a?(Array) 
+          keys.collect {|key| "#{quoted_table_name}.#{connection.quote_column_name(key)}"}.join(CompositePrimaryKeys::ID_SEP) 
+        else
+          "#{quoted_table_name}.#{connection.quote_column_name(keys)}"
+        end
+      end
+
+      def composite_join_clause(full_keys1, 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 |key1, key2|
+          "#{key1}=#{key2}"
+        end.join(" AND ")
+        "(#{where_clause})"
+      end
+    end
+  end
+end
+
+module ActiveRecord::Associations
+  class AssociationProxy #:nodoc:
+
+    def composite_where_clause(full_keys, ids)
+      full_keys = full_keys.split(CompositePrimaryKeys::ID_SEP) if full_keys.is_a?(String)
+
+      if ids.is_a?(String)
+        ids = [[ids]]
+      elsif not ids.first.is_a?(Array) # if single comp key passed, turn into an array of 1
+        ids = [ids.to_composite_ids]
+      end
+
+      where_clause = ids.map do |id_set|
+        transposed = id_set.size == 1 ? [[full_keys, id_set.first]] : [full_keys, id_set].transpose
+        transposed.map do |full_key, id|
+          "#{full_key.to_s}=#{@reflection.klass.sanitize(id)}"
+        end.join(" AND ")
+      end.join(") OR (")
+
+      "(#{where_clause})"
+    end
+
+    def composite_join_clause(full_keys1, 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 |key1, key2|
+        "#{key1}=#{key2}"
+      end.join(" AND ")
+
+      "(#{where_clause})"
+    end
+
+    def full_composite_join_clause(table1, full_keys1, table2, full_keys2)
+      connection = @reflection.active_record.connection
+      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)
+
+      quoted1 = connection.quote_table_name(table1)
+      quoted2 = connection.quote_table_name(table2)
+      
+      where_clause = [full_keys1, full_keys2].transpose.map do |key_pair|
+        "#{quoted1}.#{connection.quote_column_name(key_pair.first)}=#{quoted2}.#{connection.quote_column_name(key_pair.last)}"
+      end.join(" AND ")
+
+      "(#{where_clause})"
+    end
+
+    def full_keys(table_name, keys)
+      connection = @reflection.active_record.connection
+      quoted_table_name = connection.quote_table_name(table_name)
+      keys = keys.split(CompositePrimaryKeys::ID_SEP) if keys.is_a?(String)
+      if keys.is_a?(Array) 
+        keys.collect {|key| "#{quoted_table_name}.#{connection.quote_column_name(key)}"}.join(CompositePrimaryKeys::ID_SEP) 
+      else
+        "#{quoted_table_name}.#{connection.quote_column_name(keys)}"
+      end
+    end
+
+    def full_columns_equals(table_name, keys, quoted_ids)
+      connection = @reflection.active_record.connection
+      quoted_table_name = connection.quote_table_name(table_name)
+      if keys.is_a?(Symbol) or (keys.is_a?(String) and keys == keys.to_s.split(CompositePrimaryKeys::ID_SEP))
+        return "#{quoted_table_name}.#{connection.quote_column_name(keys)} = #{quoted_ids}"
+      end
+      keys = keys.split(CompositePrimaryKeys::ID_SEP) if keys.is_a?(String)
+      quoted_ids = quoted_ids.split(CompositePrimaryKeys::ID_SEP) if quoted_ids.is_a?(String)
+      keys_ids = [keys, quoted_ids].transpose
+      keys_ids.collect {|key, id| "(#{quoted_table_name}.#{connection.quote_column_name(key)} = #{id})"}.join(' AND ')
+    end 
+
+    def set_belongs_to_association_for(record)
+      if @reflection.options[:as]
+        record["#{@reflection.options[:as]}_id"]   = @owner.id unless @owner.new_record?
+        record["#{@reflection.options[:as]}_type"] = @owner.class.base_class.name.to_s
+      else
+        key_values = @reflection.primary_key_name.to_s.split(CompositePrimaryKeys::ID_SEP).zip([@owner.id].flatten)
+        key_values.each{|key, value| record[key] = value} unless @owner.new_record?
+      end
+    end
+  end
+
+  class HasAndBelongsToManyAssociation < AssociationCollection #:nodoc:
+    def construct_sql
+      @reflection.options[:finder_sql] &&= interpolate_sql(@reflection.options[:finder_sql])
+
+      if @reflection.options[:finder_sql]
+        @finder_sql = @reflection.options[:finder_sql]
+      else
+        @finder_sql = full_columns_equals(@reflection.options[:join_table], @reflection.primary_key_name, @owner.quoted_id)
+        @finder_sql << " AND (#{conditions})" if conditions
+      end
+
+      @join_sql = "INNER JOIN #{@reflection.active_record.connection.quote_table_name(@reflection.options[:join_table])} ON " +
+      full_composite_join_clause(@reflection.klass.table_name, @reflection.klass.primary_key, @reflection.options[:join_table], @reflection.association_foreign_key)
+    end
+  end
+
+  class HasManyAssociation < AssociationCollection #:nodoc:
+    def construct_sql
+      case
+        when @reflection.options[:finder_sql]
+          @finder_sql = interpolate_sql(@reflection.options[:finder_sql])
+
+        when @reflection.options[:as]
+          @finder_sql = 
+            "#{@reflection.klass.quoted_table_name}.#{@reflection.options[:as]}_id = #{@owner.quoted_id} AND " + 
+            "#{@reflection.klass.quoted_table_name}.#{@reflection.options[:as]}_type = #{@owner.class.quote_value(@owner.class.base_class.name.to_s)}"
+          @finder_sql << " AND (#{conditions})" if conditions
+
+        else
+          @finder_sql = full_columns_equals(@reflection.klass.table_name, @reflection.primary_key_name, @owner.quoted_id)
+          @finder_sql << " AND (#{conditions})" if conditions
+      end
+
+      if @reflection.options[:counter_sql]
+        @counter_sql = interpolate_sql(@reflection.options[:counter_sql])
+      elsif @reflection.options[:finder_sql]
+        # replace the SELECT clause with COUNT(*), preserving any hints within /* ... */
+        @reflection.options[:counter_sql] = @reflection.options[:finder_sql].sub(/SELECT (\/\*.*?\*\/ )?(.*)\bFROM\b/im) { "SELECT #{$1}COUNT(*) FROM" }
+        @counter_sql = interpolate_sql(@reflection.options[:counter_sql])
+      else
+        @counter_sql = @finder_sql
+      end
+    end
+
+    def delete_records(records)
+      if @reflection.options[:dependent]
+        records.each { |r| r.destroy }
+      else
+        connection = @reflection.active_record.connection
+        field_names = @reflection.primary_key_name.split(',')
+        field_names.collect! {|n| connection.quote_column_name(n) + " = NULL"}
+        records.each do |r|
+          where_clause = nil
+          
+          if r.quoted_id.to_s.include?(CompositePrimaryKeys::ID_SEP)
+            where_clause_terms = [@reflection.klass.primary_key, r.quoted_id].transpose.map do |pair|
+              "(#{connection.quote_column_name(pair[0])} = #{pair[1]})"
+            end
+            where_clause = where_clause_terms.join(" AND ")
+          else
+            where_clause = connection.quote_column_name(@reflection.klass.primary_key) + ' = ' +  r.quoted_id
+          end
+          
+          @reflection.klass.update_all(  field_names.join(',') , where_clause)
+        end
+      end
+    end
+  end
+
+  class HasOneAssociation < BelongsToAssociation #:nodoc:
+    def construct_sql
+      case
+        when @reflection.options[:as]
+          @finder_sql = 
+            "#{@reflection.klass.quoted_table_name}.#{@reflection.options[:as]}_id = #{@owner.quoted_id} AND " + 
+            "#{@reflection.klass.quoted_table_name}.#{@reflection.options[:as]}_type = #{@owner.class.quote_value(@owner.class.base_class.name.to_s)}"
+        else
+          @finder_sql = full_columns_equals(@reflection.klass.table_name, @reflection.primary_key_name, @owner.quoted_id)
+      end
+
+      @finder_sql << " AND (#{conditions})" if conditions
+    end
+  end
+
+  class HasManyThroughAssociation < HasManyAssociation #:nodoc:
+    def construct_conditions_with_composite_keys
+      if @reflection.through_reflection.options[:as]
+        construct_conditions_without_composite_keys
+      else
+        conditions = full_columns_equals(@reflection.through_reflection.table_name, @reflection.through_reflection.primary_key_name, @owner.quoted_id)
+        conditions << " AND (#{sql_conditions})" if sql_conditions
+        conditions
+      end
+    end
+    alias_method_chain :construct_conditions, :composite_keys
+
+    def construct_joins_with_composite_keys(custom_joins = nil)
+      if @reflection.through_reflection.options[:as] || @reflection.source_reflection.options[:as]
+        construct_joins_without_composite_keys(custom_joins)
+      else
+        if @reflection.source_reflection.macro == :belongs_to
+          reflection_primary_key = @reflection.klass.primary_key
+          source_primary_key     = @reflection.source_reflection.primary_key_name
+        else
+          reflection_primary_key = @reflection.source_reflection.primary_key_name
+          source_primary_key     = @reflection.klass.primary_key
+        end
+
+        "INNER JOIN %s ON %s #{@reflection.options[:joins]} #{custom_joins}" % [
+          @reflection.through_reflection.quoted_table_name,
+          composite_join_clause(full_keys(@reflection.table_name, reflection_primary_key), full_keys(@reflection.through_reflection.table_name, source_primary_key))
+        ]
+      end
+    end
+    alias_method_chain :construct_joins, :composite_keys
+  end
+end