Ticket #6461: nested_has_many_through_20070428b.diff

activerecord/test/associations/join_model_test.rb

@@ -350 +350 @@
-    end
-  end
-
-
-
+
+
+
+
+
-  end
-
+  def test_remote_nested_through_associations
+    author = authors(:david)
+
+    # polymorphic
+    assert_equal [tags(:general)], author.tags.uniq.sort_by { |t| t.id }
+    assert_equal [], author.invalid_tags
+
+    # non-polymorphic
+    assert_equal [author, authors(:mary)], author.similar_authors.uniq.sort_by { |t| t.id }
+  end
+
+  def test_local_and_remote_nested_through_associations
+    author = authors(:david)
+
+    # polymorphic
+    assert_equal [taggings(:welcome_general), taggings(:thinking_general), taggings(:fake)], author.tag_taggings.uniq.sort_by { |t| t.id }
+
+    expected_posts = [
+      posts(:welcome),
+      posts(:thinking),
+      posts(:sti_comments),
+      posts(:sti_post_and_comments),
+      posts(:sti_habtm),
+      posts(:eager_other)
+    ]
+    assert_equal expected_posts, author.posts_of_similar_authors.uniq.sort_by { |t| t.id }
+  end
+
+  def test_multiple_table_references_in_nested_through_associations
+    author = authors(:david)
+
+    # polymorphic
+    assert_equal [tags(:general)], author.tag_tagging_tags.uniq.sort_by { |t| t.id }
+
+    assert_equal [categorizations(:david_welcome_general), categorizations(:mary_thinking_general)], author.categorizations_of_similar_posts.uniq.sort_by { |t| t.id }
+    assert_equal [author, authors(:mary)], author.similar_authors_2.uniq.sort_by { |t| t.id }
+
+    expected_posts = [
+      posts(:welcome),
+      posts(:thinking),
+      posts(:sti_comments),
+      posts(:sti_post_and_comments),
+      posts(:sti_habtm),
+      posts(:eager_other)
+    ]
+    assert_equal expected_posts, author.posts_of_similar_authors_2.uniq.sort_by { |t| t.id }
+  end
+
-  def test_has_many_through_habtm
-    assert_raise(ActiveRecord::HasManyThroughSourceAssociationMacroError) { authors(:david).post_categories }
-  end

activerecord/test/fixtures/author.rb

@@ -55 +55 @@
-  has_many :favorite_authors, :through => :author_favorites, :order => 'name'
-
-  has_many :tagging,  :through => :posts # through polymorphic has_one
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-  has_many :post_categories, :through => :posts, :source => :categories
-
-  belongs_to :author_address

activerecord/lib/active_record/reflection.rb

@@ -187 +187 @@
-            raise HasManyThroughAssociationPolymorphicError.new(active_record.name, self, source_reflection)
-          end
-          
- && source_reflection.options[:through].nil?
+
-            raise HasManyThroughSourceAssociationMacroError.new(self)
-          end
-        end

activerecord/lib/active_record/associations/has_many_through_association.rb

@@ -157 +157 @@
-
-        # Build SQL conditions from attributes, qualified by table name.
-        def construct_conditions
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-          end
-          conditions << sql_conditions if sql_conditions
-          "(" + conditions.join(') AND (') + ")"
-        end
-
-        def construct_from
@@ -172 +209 @@
-        def construct_select(custom_select = nil)
-          selected = custom_select || @reflection.options[:select] || "#{@reflection.table_name}.*"
-        end
+        
+        # Given any belongs_to or has_many (including has_many :through) association,
+        # return the essential components of a join corresponding to that association, namely:
+        # joins: any additional joins required to get from the association's table (reflection.table_name)
+        #    to the table that's actually joining to the active record's table
+        # remote_key: the name of the key in the join table (qualified by table name) which will join
+        #    to a field of the active record's table
+        # local_key: the name of the key in the local table (not qualified by table name) which will
+        #    take part in the join
+        # conditions: any additional conditions (e.g. filtering by type for a polymorphic association,
+        #    or a :conditions clause explicitly given in the association), including a leading AND
+        def construct_join_components(custom_joins = nil, reflection = @reflection, association_class = reflection.klass, table_ids = {association_class.table_name => 1})
+        
+          # Determine the alias used for remote_table_name, if any. In all cases this will already
+          # have been assigned an ID in table_ids (either through being involved in a previous join,
+          # or as the default value defined above)
+          remote_table_alias = remote_table_name = association_class.table_name
+          remote_table_alias += "_#{table_ids[remote_table_name]}" unless table_ids[remote_table_name] == 1
+          
+          if reflection.macro == :belongs_to
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
-            end
+            
+            conditions = ''
+            if reflection.options[:polymorphic]
+              conditions += " AND #{local_table_alias}.#{reflection.options[:foreign_type]} = #{reflection.active_record.quote_value(association_class.base_class.name.to_s)}"
+            end
+            conditions += " AND #{remote_table_alias}.#{association_class.inheritance_column} = #{association_class.quote_value(association_class.name.demodulize)}" unless association_class.descends_from_active_record?
+            conditions += " AND #{interpolate_sql(association_class.send(:sanitize_sql, reflection.options[:conditions]))}" if reflection.options[:conditions]
+            {
+              :joins => "#{reflection.options[:joins]} #{custom_joins}",
+              :remote_key => "#{remote_table_alias}.#{association_class.primary_key}",
+              :local_key => reflection.primary_key_name,
+              :conditions => conditions
+            }
+          elsif reflection.macro == :has_many
+            if reflection.through_reflection
+              source_join_components = construct_join_components(nil, reflection.source_reflection, reflection.klass, table_ids)
+              through_table_alias = through_table_name = reflection.through_reflection.table_name
+              through_table_alias += "_#{table_ids[through_table_name]}" unless table_ids[through_table_name] == 1
+              through_join_components = construct_join_components(nil, reflection.through_reflection, reflection.through_reflection.klass, table_ids)
+              conditions = through_join_components[:conditions]
+              conditions += " AND #{interpolate_sql(reflection.klass.send(:sanitize_sql, reflection.options[:conditions]))}" if reflection.options[:conditions]
+              {
+                :joins => "#{source_join_components[:joins]} INNER JOIN #{through_table_name} #{through_table_alias == through_table_name ? nil : through_table_alias} ON (#{source_join_components[:remote_key]} = #{through_table_alias}.#{source_join_components[:local_key]}#{source_join_components[:conditions]}) #{through_join_components[:joins]} #{reflection.options[:joins]} #{custom_joins}",
+                :remote_key => through_join_components[:remote_key],
+                :local_key => through_join_components[:local_key],
+                :conditions => conditions
+              }
+            else
+              local_table_alias = local_table_name = reflection.active_record.table_name
+              if table_ids[local_table_name]
+                table_id = table_ids[local_table_name] += 1
+                local_table_alias += "_#{table_id}"
+              else
+                table_ids[local_table_name] = 1
+              end
+              conditions = ''
+              if reflection.options[:as]
+                conditions += " AND #{remote_table_alias}.#{reflection.options[:as]}_type = #{reflection.active_record.quote_value(reflection.active_record.base_class.name.to_s)}"
+              end
+              conditions += " AND #{remote_table_alias}.#{reflection.klass.inheritance_column} = #{reflection.klass.quote_value(reflection.klass.name.demodulize)}" unless reflection.klass.descends_from_active_record?
+              conditions += " AND (#{interpolate_sql(reflection.klass.send(:sanitize_sql, reflection.options[:conditions]))})" if reflection.options[:conditions]
+              {
+                :joins => "#{reflection.options[:joins]} #{custom_joins}",
+                :remote_key => "#{remote_table_alias}.#{reflection.primary_key_name}",
+                :local_key => reflection.klass.primary_key,
+                :conditions => conditions
+              }
+            end
-          else
-
-
-
-
-
-
-
-
+
+
-          end
+        end
-
-
-
-
-
-
-
+
+
+
-        end
-
-        def construct_scope
@@ -232 +325 @@
-        end
-
-        def conditions
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-        end
-
-        alias_method :sql_conditions, :conditions
+
+        def get_through_conditions(reflection = @reflection, reflections_to_skip = [])
+          conditions = []
+
+          # Make sure we haven't added the conditions for this reflection already
+          # This can occur if the same model/table is gone through more than once
+          if !reflections_to_skip.include?(reflection)
+            reflections_to_skip << reflection
+
+            # Add the source reflection's conditions
+            if source_reflection = reflection.source_reflection
+              conditions << interpolate_sql(@reflection.active_record.send(:sanitize_sql, source_reflection.options[:conditions])) if source_reflection.options[:conditions]
+              conditions.concat(get_through_conditions(source_reflection, reflections_to_skip))
+            end
+
+            # Add the through reflection's conditions
+            if through_reflection = reflection.through_reflection
+              conditions << interpolate_sql(@reflection.active_record.send(:sanitize_sql, through_reflection.options[:conditions])) if through_reflection.options[:conditions]
+              conditions.concat(get_through_conditions(through_reflection, reflections_to_skip))
+            end
+          end
+
+          conditions
+        end
-    end
-  end
-end

activerecord/lib/active_record/associations.rb

@@ -1527 +1527 @@
-              @aliased_table_name = table_name #.tr('.', '_') # start with the table name, sub out any .'s
-              @parent_table_name  = parent.active_record.table_name
-
-
++
-                join_dependency.table_aliases[aliased_table_name] += 1
-              end
-