Ticket #6461: nested_has_many_through_updated.diff

activerecord/lib/active_record/associations/has_many_through_association.rb

@@ -155 +155 @@
-
-        # Build SQL conditions from attributes, qualified by table name.
-        def construct_conditions
-
-
+
+
+
+
+
-            "#{table_name}.#{attr} = #{value}"
-          end
+
-          conditions << sql_conditions if sql_conditions
-          "(" + conditions.join(') AND (') + ")"
-        end
@@ -163 +167 @@
-          "(" + conditions.join(') AND (') + ")"
-        end
-
+        # Look ahead through a reflection to find out where the deepest
+        # association is in the class that doesn't have a through relationship.
+        # For example,
+        # 
+        #  class A < ActiveRecord::Base
+        #    has_many :bs
+        #    has_many :cs, :through => :bs
+        #    has_many :ds, :through => :cs
+        #    has_many :es, :through => ds
+        #  end
+        # 
+        # Here, our :bs association is the deepest when going into any of the
+        # :through associations.  In addition to returning the :bs reflection,
+        # it will also return the table alias id for use in the database query.
+        # The reason for an alias id is that you could potentially go through
+        # the same table more than once.  In this case, you need to keep track
+        # of how many times you went through the table so that the proper alias
+        # can be applied to the table when running the query.
+        def find_deepest_through(reflection, table_ids = {@reflection.table_name => 1, reflection.table_name => 1})
+          # Don't overwrite the original hash since this only a look-ahead
+          table_ids = table_ids.dup
+
+          if through_reflection = reflection.through_reflection
+            table_name = through_reflection.table_name
+            table_ids[table_name] = (table_ids[table_name] || 0) + 1
+
+            find_deepest_through(through_reflection, table_ids)
+          else
+            table_id = table_ids[reflection.table_name] || 1
+            
+            # Only running into the table once means we don't need a table id
+            return reflection, (table_id > 1 ? table_id : nil)
+          end
+        end
+
-        def construct_from
-          @reflection.table_name
-        end
@@ -171 +210 @@
-          selected = custom_select || @reflection.options[:select] || "#{@reflection.table_name}.*"
-        end
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-          polymorphic_join = nil
-@reflection.through_reflection.options[:as] || @reflection.
-@
-@reflection.
+through_reflection.options[:as] || 
+
+
-          else
-
-
-
+
+
+
+
-              polymorphic_join = "AND %s.%s = %s" % [
-@reflection.table_name, "#{@reflection.
-@reflection.
+reflection_table_name, "#{
+
-              ]
-            end
-          end
@@ -187 +264 @@
-            end
-          end
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
-            polymorphic_join
-          ]
-        end
@@ -224 +307 @@
-        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/reflection.rb

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

activerecord/test/associations/join_model_test.rb

@@ -336 +336 @@
-    end
-  end
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-  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