kovyrin-composite_primary_keys 2.3.2

data/lib/adapter_helper/base.rb

@@ -0,0 +1,63 @@
+module AdapterHelper
+  class Base
+    class << self
+      attr_accessor :adapter
+
+      def load_connection_from_env(adapter)
+        self.adapter = adapter
+        unless ENV['cpk_adapters']
+          puts error_msg_setup_helper
+          exit
+        end
+
+        ActiveRecord::Base.configurations = YAML.load(ENV['cpk_adapters'])
+        unless spec = ActiveRecord::Base.configurations[adapter]
+          puts error_msg_adapter_helper
+          exit
+        end
+        spec[:adapter] = adapter
+        spec
+      end
+    
+      def error_msg_setup_helper
+        <<-EOS
+Setup Helper:
+  CPK now has a place for your individual testing configuration.
+  That is, instead of hardcoding it in the Rakefile and test/connections files,
+  there is now a local/database_connections.rb file that is NOT in the
+  repository. Your personal DB information (username, password etc) can
+  be stored here without making it difficult to submit patches etc.
+
+Installation:
+  i)   cp locals/database_connections.rb.sample locals/database_connections.rb
+  ii)  For #{adapter} connection details see "Adapter Setup Helper" below.
+  iii) Rerun this task
+  
+#{error_msg_adapter_helper}
+  
+Current ENV:
+  #{ENV.inspect}
+        EOS
+      end
+        
+      def error_msg_adapter_helper
+        <<-EOS
+Adapter Setup Helper:
+  To run #{adapter} tests, you need to setup your #{adapter} connections.
+  In your local/database_connections.rb file, within the ENV['cpk_adapter'] hash, add:
+      "#{adapter}" => { adapter settings }
+
+  That is, it will look like:
+    ENV['cpk_adapters'] = {
+      "#{adapter}" => {
+        :adapter  => "#{adapter}",
+        :username => "root",
+        :password => "root",
+        # ...
+      }
+    }.to_yaml
+        EOS
+      end
+    end
+  end
+end

data/lib/adapter_helper/mysql.rb

@@ -0,0 +1,13 @@
+require File.join(File.dirname(__FILE__), 'base')
+
+module AdapterHelper
+  class MySQL < Base
+    class << self
+      def load_connection_from_env
+        spec = super('mysql')
+        spec[:database] ||= 'composite_primary_keys_unittest'
+        spec
+      end
+    end
+  end
+end

data/lib/adapter_helper/oracle.rb

@@ -0,0 +1,12 @@
+require File.join(File.dirname(__FILE__), 'base')
+
+module AdapterHelper
+  class Oracle < Base
+    class << self
+      def load_connection_from_env
+        spec = super('oracle')
+        spec
+      end
+    end
+  end
+end

data/lib/adapter_helper/postgresql.rb

@@ -0,0 +1,13 @@
+require File.join(File.dirname(__FILE__), 'base')
+
+module AdapterHelper
+  class Postgresql < Base
+    class << self
+      def load_connection_from_env
+        spec = super('postgresql')
+        spec[:database] ||= 'composite_primary_keys_unittest'
+        spec
+      end
+    end
+  end
+end

data/lib/adapter_helper/sqlite3.rb

@@ -0,0 +1,13 @@
+require File.join(File.dirname(__FILE__), 'base')
+
+module AdapterHelper
+  class Sqlite3 < Base
+    class << self
+      def load_connection_from_env
+        spec = super('sqlite3')
+        spec[:dbfile] ||= "tmp/test.db"
+        spec
+      end
+    end
+  end
+end

data/lib/composite_primary_keys/association_preload.rb

@@ -0,0 +1,236 @@
+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.#{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, 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.#{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(reflection, 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|
+                key = through_primary_key.to_s.split(CompositePrimaryKeys::ID_SEP).map{|k| through_record.send(k)}.join(CompositePrimaryKeys::ID_SEP)
+                add_preloaded_records_to_collection(id_to_record_map[key], 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
+            # 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
+
+          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
+            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}.#{connection.quote_column_name(key)} = ?"}.join(" AND ") + ")"
+              end.join(" OR ")
+
+              conditions = [where, ids].flatten
+            else
+              conditions = ["#{table_name}.#{connection.quote_column_name(primary_key)} IN (?)", id_map.keys.uniq]
+            end
+
+            conditions.first << append_conditions(reflection, 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][:records]
+            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
+            connection = reflection.active_record.connection
+            foreign_key = reflection.primary_key_name
+            conditions = ["#{table_name}.#{connection.quote_column_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| "#{table_name}.#{connection.quote_column_name(key)} = ?"}.join(" AND ") + ")"
+              end.join(" OR ")
+
+              conditions = [where, ids].flatten
+            end
+          end
+
+          conditions.first << append_conditions(reflection, 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(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|
+            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

data/lib/composite_primary_keys/associations.rb

@@ -0,0 +1,427 @@
+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
+          association = join.instantiate(row) unless [*join.aliased_primary_key].any? { |key| row[key].nil? }
+          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