1 files changed, 31 insertions, 87 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 eb65234dfb..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,32 +2,15 @@ module ActiveRecord
   # = Active Record Has And Belongs To Many Association
   module Associations
     class HasAndBelongsToManyAssociation < AssociationCollection #:nodoc:
-      def create(attributes = {})
-        create_record(attributes) { |record| insert_record(record) }
-      end
-
-      def create!(attributes = {})
-        create_record(attributes) { |record| insert_record(record, true) }
-      end
-
-      def columns
-        @reflection.columns(@reflection.options[:join_table], "#{@reflection.options[:join_table]} Columns")
-      end
+      attr_reader :join_table
 
-      def reset_column_information
-        @reflection.reset_column_information
-      end
-
-      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 @join_sql
-          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
@@ -35,99 +18,60 @@ module ActiveRecord
 
         def insert_record(record, force = true, validate = true)
           if record.new_record?
-            if force
-              record.save!
-            else
-              return false unless record.save(:validate => validate)
-            end
+            return false unless save_record(record, force, validate)
           end
 
           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 = Hash[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
+            )
 
-            relation.insert(attributes)
+            @owner.connection.insert stmt.to_sql
           end
 
-          return true
+          true
         end
 
         def delete_records(records)
           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])
-            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))
-            ).delete
+            ).compile_delete
+            @owner.connection.delete stmt.to_sql
           end
         end
 
-        def construct_sql
-          if @reflection.options[:finder_sql]
-            @finder_sql = interpolate_sql(@reflection.options[:finder_sql])
-          else
-            @finder_sql = "#{@owner.connection.quote_table_name @reflection.options[:join_table]}.#{@reflection.primary_key_name} = #{owner_quoted_id} "
-            @finder_sql << " AND (#{conditions})" if conditions
-          end
+        def construct_joins
+          right = join_table
+          left  = @reflection.klass.arel_table
 
-          @join_sql = "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}"
+          condition = left[@reflection.klass.primary_key].eq(
+            right[@reflection.association_foreign_key])
 
-          construct_counter_sql
+          right.create_join(right, right.create_on(condition))
         end
 
-        def construct_scope
-          { :find => {  :conditions => @finder_sql,
-                        :joins => @join_sql,
-                        :readonly => false,
-                        :order => @reflection.options[:order],
-                        :include => @reflection.options[:include],
-                        :limit => @reflection.options[:limit] } }
+        def construct_owner_conditions
+          super(join_table)
         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 association_scope
+          super.joins(construct_joins)
         end
 
-      private
-        def create_record(attributes, &block)
-          # Can't use Base.create because the foreign key may be a protected attribute.
-          ensure_owner_is_not_new
-          if attributes.is_a?(Array)
-            attributes.collect { |attr| create(attr) }
-          else
-            build_record(attributes, &block)
-          end
+        def select_value
+          super || @reflection.klass.arel_table[Arel.star]
         end
 
-        def record_timestamp_columns(record)
-          if record.record_timestamps
-            record.send(:all_timestamp_attributes).map { |x| x.to_s }
-          else
-            []
-          end
+      private
+        def invertible_for?(record)
+          false
         end
     end
   end