1 files changed, 21 insertions, 62 deletions

diff --git a/activerecord/lib/active_record/associations/has_and_belongs_to_many_association.rb b/activerecord/lib/active_record/associations/has_and_belongs_to_many_association.rb
index b1d454545f..b28554dce1 100644
--- a/activerecord/lib/active_record/associations/has_and_belongs_to_many_association.rb
+++ b/activerecord/lib/active_record/associations/has_and_belongs_to_many_association.rb
@@ -2,24 +2,15 @@ module ActiveRecord
   # = Active Record Has And Belongs To Many Association
   module Associations
     class HasAndBelongsToManyAssociation < AssociationCollection #:nodoc:
-      def columns
-        @reflection.columns(@reflection.options[:join_table], "#{@reflection.options[:join_table]} Columns")
-      end
-
-      def reset_column_information
-        @reflection.reset_column_information
-      end
+      attr_reader :join_table
 
-      def has_primary_key?
-        @has_primary_key ||= @owner.connection.supports_primary_key? && @owner.connection.primary_key(@reflection.options[:join_table])
+      def initialize(owner, reflection)
+        @join_table_name = reflection.options[:join_table]
+        @join_table      = Arel::Table.new(@join_table_name)
+        super
       end
 
       protected
-        def construct_find_options!(options)
-          options[:joins]      = Arel::SqlLiteral.new(@scope[:find][:joins])
-          options[:readonly]   = finding_with_ambiguous_select?(options[:select] || @reflection.options[:select])
-          options[:select]   ||= (@reflection.options[:select] || Arel::SqlLiteral.new('*'))
-        end
 
         def count_records
           load_target.size
@@ -33,26 +24,11 @@ module ActiveRecord
           if @reflection.options[:insert_sql]
             @owner.connection.insert(interpolate_sql(@reflection.options[:insert_sql], record))
           else
-            relation   = Arel::Table.new(@reflection.options[:join_table])
-            timestamps = record_timestamp_columns(record)
-            timezone   = record.send(:current_time_from_proper_timezone) if timestamps.any?
-
-            attributes = columns.map do |column|
-              name = column.name
-              value = case name.to_s
-                when @reflection.primary_key_name.to_s
-                  @owner.id
-                when @reflection.association_foreign_key.to_s
-                  record.id
-                when *timestamps
-                  timezone
-                else
-                  @owner.send(:quote_value, record[name], column) if record.has_attribute?(name)
-              end
-              [relation[name], value] unless value.nil?
-            end
+            stmt = join_table.compile_insert(
+              join_table[@reflection.foreign_key]             => @owner.id,
+              join_table[@reflection.association_foreign_key] => record.id
+            )
 
-            stmt = relation.compile_insert Hash[attributes]
             @owner.connection.insert stmt.to_sql
           end
 
@@ -63,8 +39,8 @@ module ActiveRecord
           if sql = @reflection.options[:delete_sql]
             records.each { |record| @owner.connection.delete(interpolate_sql(sql, record)) }
           else
-            relation = Arel::Table.new(@reflection.options[:join_table])
-            stmt = relation.where(relation[@reflection.primary_key_name].eq(@owner.id).
+            relation = join_table
+            stmt = relation.where(relation[@reflection.foreign_key].eq(@owner.id).
               and(relation[@reflection.association_foreign_key].in(records.map { |x| x.id }.compact))
             ).compile_delete
             @owner.connection.delete stmt.to_sql
@@ -72,45 +48,28 @@ module ActiveRecord
         end
 
         def construct_joins
-          "INNER JOIN #{@owner.connection.quote_table_name @reflection.options[:join_table]} ON #{@reflection.quoted_table_name}.#{@reflection.klass.primary_key} = #{@owner.connection.quote_table_name @reflection.options[:join_table]}.#{@reflection.association_foreign_key}"
-        end
+          right = join_table
+          left  = @reflection.klass.arel_table
 
-        def join_table
-          Arel::Table.new(@reflection.options[:join_table])
+          condition = left[@reflection.klass.primary_key].eq(
+            right[@reflection.association_foreign_key])
+
+          right.create_join(right, right.create_on(condition))
         end
 
         def construct_owner_conditions
           super(join_table)
         end
 
-        def construct_find_scope
-          {
-            :conditions => construct_conditions,
-            :joins      => construct_joins,
-            :readonly   => false,
-            :order      => @reflection.options[:order],
-            :include    => @reflection.options[:include],
-            :limit      => @reflection.options[:limit]
-          }
+        def association_scope
+          super.joins(construct_joins)
         end
 
-        # Join tables with additional columns on top of the two foreign keys must be considered
-        # ambiguous unless a select clause has been explicitly defined. Otherwise you can get
-        # broken records back, if, for example, the join column also has an id column. This will
-        # then overwrite the id column of the records coming back.
-        def finding_with_ambiguous_select?(select_clause)
-          !select_clause && columns.size != 2
+        def select_value
+          super || @reflection.klass.arel_table[Arel.star]
         end
 
       private
-        def record_timestamp_columns(record)
-          if record.record_timestamps
-            record.send(:all_timestamp_attributes).map { |x| x.to_s }
-          else
-            []
-          end
-        end
-
         def invertible_for?(record)
           false
         end