Ticket #8838: duplicate_join_table_names_fix_with_tests.diff

activerecord/lib/active_record/base.rb

@@ -1167 +1167 @@
-          connection.add_lock!(sql, options)
-        end
-
+        # Returns the names (or aliases if used) of each table used in a JOIN fragment
+        def table_aliases_from_join_fragment(sql)
+          return [] if sql.blank?
+          return sql.scan(/JOIN\s+(`[^`]+`|"[^"]+"|\[[^\]]+\]|\S+)(?:\s+(?:AS\s+)?(`[^`]+`|"[^"]+"|\[[^\]]+\]|\S+))?/i).collect do |name|
+            ((name[1] =~ /^ON$/i) ? name[0] : (name[1] || name[0])).gsub(/^[`"\[]?(.*)[`"\]]?$/, '\1')
+          end
+        end
+
-        # The optional scope argument is for the current :find scope.
-        def add_joins!(sql, options, scope = :auto)
-          scope = scope(:find) if :auto == scope
-          join = (scope && scope[:joins]) || options[:joins]
-
+
+
+
-        end
-
+        # Appends +addition+ to +sql+ by checking for table name clashes between the two
+        # fragments. Table aliases in +sql+ are changed as necessary before appending +addition+.
+        # It's done this way round so that manually specifying <tt>:joins</tt> retains the table name
+        # you specify, reducing the potential for confusion.
+        def extend_sql_avoiding_table_naming_clashes!(sql, addition)
+          used_table_aliases = table_aliases_from_join_fragment(addition)
+          old_table_aliases = table_aliases_from_join_fragment(sql)
+          (used_table_aliases & old_table_aliases).each do |join_table_alias|
+            i = 0
+            begin
+              i += 1
+              new_alias = "renamed_join_table_#{i}"
+            end until !used_table_aliases.include?(new_alias)
+            convert_table_name_to_new_alias!(sql, join_table_alias, new_alias)
+          end
+          sql << " #{addition} "
+        end
+
+        # Modifies the SQL fragment such that every instance of +old_table_name+
+        # is replaced by or aliased using (in JOIN ... AS blocks) +new_alias+.
+        def convert_table_name_to_new_alias!(sql, old_table_name, new_alias)
+          regex = Regexp.new("(?:(?:JOIN|AS)?\\s+|\\()[`\"\\[]?#{old_table_name}[`\"\\]]?(?:\\s+(?:AS\\s+)?(?:`[^`]+`|\"[^\"]+\"|\\[[^\\]]+\\]|\\S+)|\\.|\\s)", Regexp::IGNORECASE)
+          sql.gsub!(regex) do |match|
+            prefix = (match =~ /^\(/) ? '(' : ''
+            suffix = match.gsub(/^.*?(\s+ON|.)$/i, '\1')
+            if test = match.match(/^JOIN\s+(?:`[^`]+`|"[^"]+"|\[[^\]]+\]|\S+)(\s+(?:AS\s+)?(?:`[^`]+`|"[^"]+"|\[[^\]]+\]|\S+))/i) and !(test.captures.first =~ /^ ON$/i)
+              # If the table name is already aliased within this match, don't replace it
+              result = match
+            else
+              replacement = "JOIN #{old_table_name} AS #{new_alias}" if match =~ /^JOIN\s/i
+              replacement = "AS #{new_alias}" if match =~ /^AS\s/i
+              replacement = " #{new_alias}" unless match =~ /^(JOIN|AS)\s/i
+              result = "#{prefix}#{replacement}#{suffix}"
+            end
+            result
+          end
+        end
+
-        # Adds a sanitized version of +conditions+ to the +sql+ string. Note that the passed-in +sql+ string is changed.
-        # The optional scope argument is for the current :find scope.
-        def add_conditions!(sql, conditions, scope = :auto)

activerecord/test/associations/eager_test.rb

@@ -240 +240 @@
-    assert posts[1].categories.include?(categories(:general))
-  end
-
+  def test_eager_association_loading_with_circular_habtm
+    assert_equal 4, categories(:general).posts.find(:all, :include => :categories).size
+    assert_equal 2, categories(:general).posts.find(:first, :include => :categories, :conditions => 'posts.id = 1').categories.size
+  end
+
-  def test_eager_with_inheritance
-    posts = SpecialPost.find(:all, :include => [ :comments ])
-  end
@@ -390 +395 @@
-      assert_equal 3, authors(:david).posts_with_comments.count(:conditions => "length(comments.body) > 15")
-    end
-  end
+
+  def test_eager_load_with_inner_join
+    assert_not_nil posts(:welcome)
+    assert posts(:welcome).people.size > 0
+    assert posts(:welcome).people.find(:all).size > 0
+    id = posts(:welcome).id
+    assert_equal posts(:welcome).people.find(:all).size, posts(:welcome).people.find(:all, :include => :posts).size
+    assert_equal posts(:welcome).people.find(:all).size, Person.find(:all, :include => :posts, :joins => 'inner join readers on readers.person_id = people.id', :conditions => ['readers.post_id = ?',id]).size
+  end
-end