taking advantage of the JoinSource node in the SQL AST

activerecord/lib/active_record/associations/class_methods/join_dependency.rb

@@ -47,24 +47,16 @@ def columns
         end
 
         def count_aliases_from_table_joins(name)
-          return 0 if !@table_joins || Arel::Table === @table_joins
+          return 0 if Arel::Table === @table_joins
 
           # quoted_name should be downcased as some database adapters (Oracle) return quoted name in uppercase
           quoted_name = active_record.connection.quote_table_name(name).downcase
 
-          @table_joins.grep(Arel::Nodes::Join).map { |join|
-            right = join.right
-            case right
-            when Arel::Table
-              right.name.downcase == name ? 1 : 0
-            when String
-              # Table names + table aliases
-              right.downcase.scan(
-                /join(?:\s+\w+)?\s+(\S+\s+)?#{quoted_name}\son/
-              ).size
-            else
-              0
-            end
+          @table_joins.map { |join|
+            # Table names + table aliases
+            join.left.downcase.scan(
+              /join(?:\s+\w+)?\s+(\S+\s+)?#{quoted_name}\son/
+            ).size
           }.sum
         end
 

activerecord/lib/active_record/associations/class_methods/join_dependency/join_association.rb

@@ -138,7 +138,6 @@ def join_target_table(relation, condition)
             ands = relation.create_and(conditions)
 
             join = relation.create_join(
-              relation.froms.first,
               target_table,
               relation.create_on(ands),
               join_type)

activerecord/lib/active_record/relation/finder_methods.rb

@@ -187,7 +187,7 @@ def exists?(id = nil)
 
     def find_with_associations
       including = (@eager_load_values + @includes_values).uniq
-      join_dependency = ActiveRecord::Associations::ClassMethods::JoinDependency.new(@klass, including, nil)
+      join_dependency = ActiveRecord::Associations::ClassMethods::JoinDependency.new(@klass, including, [])
       rows = construct_relation_for_association_find(join_dependency).to_a
       join_dependency.instantiate(rows)
     rescue ThrowResult

activerecord/lib/active_record/relation/query_methods.rb

@@ -191,27 +191,19 @@ def build_arel
     def custom_join_ast(table, joins)
       joins = joins.reject { |join| join.blank? }
 
-      return if joins.empty?
+      return [] if joins.empty?
 
       @implicit_readonly = true
 
-      joins.map! do |join|
+      joins.map do |join|
         case join
         when Array
           join = Arel.sql(join.join(' ')) if array_of_strings?(join)
         when String
           join = Arel.sql(join)
         end
-        join
+        table.create_string_join(join)
       end
-
-      head = table.create_string_join(table, joins.shift)
-
-      joins.inject(head) do |ast, join|
-        ast.right = table.create_string_join(ast.right, join)
-      end
-
-      head
     end
 
     def collapse_wheres(arel, wheres)
@@ -256,9 +248,9 @@ def build_joins(manager, joins)
       stashed_association_joins = joins.grep(ActiveRecord::Associations::ClassMethods::JoinDependency::JoinAssociation)
 
       non_association_joins = (joins - association_joins - stashed_association_joins)
-      join_ast = custom_join_ast(manager.froms.first, non_association_joins)
+      join_list = custom_join_ast(manager, non_association_joins)
 
-      join_dependency = ActiveRecord::Associations::ClassMethods::JoinDependency.new(@klass, association_joins, join_ast)
+      join_dependency = ActiveRecord::Associations::ClassMethods::JoinDependency.new(@klass, association_joins, join_list)
 
       join_dependency.graft(*stashed_association_joins)
 
@@ -269,10 +261,9 @@ def build_joins(manager, joins)
         association.join_to(manager)
       end
 
-      return manager unless join_ast
+      return manager unless join_list
 
-      join_ast.left = manager.froms.first
-      manager.from join_ast
+      join_list.each { |j| manager.from j }
       manager
     end