activerecord 3.0.20 → 3.1.0.beta1

data/lib/active_record/relation/batches.rb

@@ -1,7 +1,7 @@
 require 'active_support/core_ext/object/blank'
 
 module ActiveRecord
-  module Batches # :nodoc:
+  module Batches
     # Yields each record that was found by the find +options+. The find is
     # performed by find_in_batches with a batch size of 1000 (or as
     # specified by the <tt>:batch_size</tt> option).
@@ -20,6 +20,8 @@ module ActiveRecord
       find_in_batches(options) do |records|
         records.each { |record| yield record }
       end
+
+      self
     end
 
     # Yields each batch of records that was found by the find +options+ as
@@ -37,7 +39,7 @@ module ActiveRecord
     # ascending on the primary key ("id ASC") to make the batch ordering
     # work. This also mean that this method only works with integer-based
     # primary keys. You can't set the limit either, that's used to control
-    # the the batch sizes.
+    # the batch sizes.
     #
     # Example:
     #
@@ -63,7 +65,7 @@ module ActiveRecord
       batch_size = options.delete(:batch_size) || 1000
 
       relation = relation.except(:order).order(batch_order).limit(batch_size)
-      records = relation.where(primary_key.gteq(start)).all
+      records = relation.where(table[primary_key].gteq(start)).all
 
       while records.any?
         yield records
@@ -71,7 +73,7 @@ module ActiveRecord
         break if records.size < batch_size
 
         if primary_key_offset = records.last.id
-          records = relation.where(primary_key.gt(primary_key_offset)).to_a
+          records = relation.where(table[primary_key].gt(primary_key_offset)).to_a
         else
           raise "Primary key not included in the custom select clause"
         end
@@ -81,7 +83,7 @@ module ActiveRecord
     private
 
     def batch_order
-      "#{@klass.quoted_table_name}.#{@klass.quoted_primary_key} ASC"
+      "#{quoted_table_name}.#{quoted_primary_key} ASC"
     end
   end
 end

data/lib/active_record/relation/calculations.rb

@@ -166,9 +166,9 @@ module ActiveRecord
       if operation == "count"
         column_name ||= (select_for_count || :all)
 
-        if arel.join_sql =~ /LEFT OUTER/i
+        unless arel.ast.grep(Arel::Nodes::OuterJoin).empty?
           distinct = true
-          column_name = @klass.primary_key if column_name == :all
+          column_name = primary_key if column_name == :all
         end
 
         distinct = nil if column_name =~ /\s*DISTINCT\s+/i
@@ -196,29 +196,36 @@ module ActiveRecord
     end
 
     def execute_simple_calculation(operation, column_name, distinct) #:nodoc:
-      column = aggregate_column(column_name)
-
       # Postgresql doesn't like ORDER BY when there are no GROUP BY
       relation = except(:order)
-      select_value = operation_over_aggregate_column(column, operation, distinct)
 
-      relation.select_values = [select_value]
+      if operation == "count" && (relation.limit_value || relation.offset_value)
+        # Shortcut when limit is zero.
+        return 0 if relation.limit_value == 0
+
+        query_builder = build_count_subquery(relation, column_name, distinct)
+      else
+        column = aggregate_column(column_name)
+
+        select_value = operation_over_aggregate_column(column, operation, distinct)
+
+        relation.select_values = [select_value]
+
+        query_builder = relation.arel
+      end
 
-      type_cast_calculated_value(@klass.connection.select_value(relation.to_sql), column_for(column_name), operation)
+      type_cast_calculated_value(@klass.connection.select_value(query_builder.to_sql), column_for(column_name), operation)
     end
 
     def execute_grouped_calculation(operation, column_name, distinct) #:nodoc:
       group_attr      = @group_values
       association     = @klass.reflect_on_association(group_attr.first.to_sym)
       associated      = group_attr.size == 1 && association && association.macro == :belongs_to # only count belongs_to associations
-      group_fields  = Array(associated ? association.primary_key_name : group_attr)
-      group_aliases = []
-      group_columns = {}
-      
-      group_fields.each do |field|
-        group_aliases << column_alias_for(field)
-        group_columns[column_alias_for(field)] = column_for(field)
-      end
+      group_fields  = Array(associated ? association.foreign_key : group_attr)
+      group_aliases = group_fields.map { |field| column_alias_for(field) }
+      group_columns = group_aliases.zip(group_fields).map { |aliaz,field|
+        [aliaz, column_for(field)]
+      }
 
       group = @klass.connection.adapter_name == 'FrontBase' ? group_aliases : group_fields
 
@@ -228,9 +235,19 @@ module ActiveRecord
         aggregate_alias = column_alias_for(operation, column_name)
       end
 
+      select_values = [
+        operation_over_aggregate_column(
+          aggregate_column(column_name),
+          operation,
+          distinct).as(aggregate_alias)
+      ]
+
+      select_values.concat group_fields.zip(group_aliases).map { |field,aliaz|
+        "#{field} AS #{aliaz}"
+      }
+
       relation = except(:group).group(group.join(','))
-      relation.select_values = [ operation_over_aggregate_column(aggregate_column(column_name), operation, distinct).as(aggregate_alias) ]
-      group_fields.each_index{ |i| relation.select_values << "#{group_fields[i]} AS #{group_aliases[i]}" }
+      relation.select_values = select_values
 
       calculated_data = @klass.connection.select_all(relation.to_sql)
 
@@ -241,7 +258,9 @@ module ActiveRecord
       end
 
       ActiveSupport::OrderedHash[calculated_data.map do |row|
-        key   = group_aliases.map{|group_alias| type_cast_calculated_value(row[group_alias], group_columns[group_alias])}
+        key   = group_columns.map { |aliaz, column|
+          type_cast_calculated_value(row[aliaz], column)
+        }
         key   = key.first if key.size == 1
         key = key_records[key] if associated
         [key, type_cast_calculated_value(row[aggregate_alias], column_for(column_name), operation)]
@@ -291,5 +310,18 @@ module ActiveRecord
         select if select !~ /(,|\*)/
       end
     end
+
+    def build_count_subquery(relation, column_name, distinct)
+      column_alias = Arel.sql('count_column')
+      subquery_alias = Arel.sql('subquery_for_count')
+
+      aliased_column = aggregate_column(column_name == :all ? 1 : column_name).as(column_alias)
+      relation.select_values = [aliased_column]
+      subquery = relation.arel.as(subquery_alias)
+
+      sm = Arel::SelectManager.new relation.engine
+      select_value = operation_over_aggregate_column(column_alias, 'count', distinct)
+      sm.project(select_value).from(subquery)
+    end
   end
 end

data/lib/active_record/relation/finder_methods.rb

@@ -19,7 +19,7 @@ module ActiveRecord
     #
     # All approaches accept an options hash as their last parameter.
     #
-    # ==== Parameters
+    # ==== Options
     #
     # * <tt>:conditions</tt> - An SQL fragment like "administrator = 1", <tt>["user_name = ?", username]</tt>,
     #   or <tt>["user_name = :user_name", { :user_name => user_name }]</tt>. See conditions in the intro.
@@ -123,6 +123,12 @@ module ActiveRecord
       end
     end
 
+    # Same as +first+ but raises <tt>ActiveRecord::RecordNotFound</tt> if no record
+    # is found. Note that <tt>first!</tt> accepts no arguments.
+    def first!
+      first or raise RecordNotFound
+    end
+
     # A convenience wrapper for <tt>find(:last, *args)</tt>. You can pass in all the
     # same arguments to this method as you can to <tt>find(:last)</tt>.
     def last(*args)
@@ -137,6 +143,12 @@ module ActiveRecord
       end
     end
 
+    # Same as +last+ but raises <tt>ActiveRecord::RecordNotFound</tt> if no record
+    # is found. Note that <tt>last!</tt> accepts no arguments.
+    def last!
+      last or raise RecordNotFound
+    end
+
     # A convenience wrapper for <tt>find(:all, *args)</tt>. You can pass in all the
     # same arguments to this method as you can to <tt>find(:all)</tt>.
     def all(*args)
@@ -168,9 +180,7 @@ module ActiveRecord
     #   Person.exists?(:name => "David")
     #   Person.exists?(['name LIKE ?', "%#{query}%"])
     #   Person.exists?
-    def exists?(id = false)
-      return false if id.nil?
-
+    def exists?(id = nil)
       id = id.id if ActiveRecord::Base === id
 
       join_dependency = construct_join_dependency_for_association_find
@@ -181,7 +191,7 @@ module ActiveRecord
       when Array, Hash
         relation = relation.where(id)
       else
-        relation = relation.where(table[primary_key.name].eq(id)) if id
+        relation = relation.where(table[primary_key].eq(id)) if id
       end
 
       connection.select_value(relation.to_sql) ? true : false
@@ -191,7 +201,8 @@ module ActiveRecord
 
     def find_with_associations
       join_dependency = construct_join_dependency_for_association_find
-      rows = construct_relation_for_association_find(join_dependency).to_a
+      relation = construct_relation_for_association_find(join_dependency)
+      rows = connection.select_all(relation.to_sql, 'SQL', relation.bind_values)
       join_dependency.instantiate(rows)
     rescue ThrowResult
       []
@@ -199,18 +210,18 @@ module ActiveRecord
 
     def construct_join_dependency_for_association_find
       including = (@eager_load_values + @includes_values).uniq
-      join_dependency = ActiveRecord::Associations::ClassMethods::JoinDependency.new(@klass, including, nil)
+      ActiveRecord::Associations::JoinDependency.new(@klass, including, [])
     end
 
     def construct_relation_for_association_calculations
       including = (@eager_load_values + @includes_values).uniq
-      join_dependency = ActiveRecord::Associations::ClassMethods::JoinDependency.new(@klass, including, arel.join_sql)
+      join_dependency = ActiveRecord::Associations::JoinDependency.new(@klass, including, arel.froms.first)
       relation = except(:includes, :eager_load, :preload)
       apply_join_dependency(relation, join_dependency)
     end
 
     def construct_relation_for_association_find(join_dependency)
-      relation = except(:includes, :eager_load, :preload, :select).select(column_aliases(join_dependency))
+      relation = except(:includes, :eager_load, :preload, :select).select(join_dependency.columns)
       apply_join_dependency(relation, join_dependency)
     end
 
@@ -232,11 +243,13 @@ module ActiveRecord
     end
 
     def construct_limited_ids_condition(relation)
-      orders = relation.order_values.join(", ")
-      values = @klass.connection.distinct("#{@klass.connection.quote_table_name @klass.table_name}.#{@klass.primary_key}", orders)
+      orders = relation.order_values
+      values = @klass.connection.distinct("#{@klass.connection.quote_table_name table_name}.#{primary_key}", orders)
 
-      ids_array = relation.select(values).collect {|row| row[@klass.primary_key]}
-      ids_array.empty? ? raise(ThrowResult) : primary_key.in(ids_array)
+      relation = relation.dup
+
+      ids_array = relation.select(values).collect {|row| row[primary_key]}
+      ids_array.empty? ? raise(ThrowResult) : table[primary_key].in(ids_array)
     end
 
     def find_by_attributes(match, attributes, *args)
@@ -266,8 +279,8 @@ module ActiveRecord
 
       unless record
         record = @klass.new do |r|
-          r.send(:attributes=, protected_attributes_for_create, true) unless protected_attributes_for_create.empty?
-          r.send(:attributes=, unprotected_attributes_for_create, false) unless unprotected_attributes_for_create.empty?
+          r.assign_attributes(protected_attributes_for_create)
+          r.assign_attributes(unprotected_attributes_for_create, :without_protection => true)
         end
         yield(record) if block_given?
         record.save if match.instantiator == :create
@@ -298,19 +311,33 @@ module ActiveRecord
     def find_one(id)
       id = id.id if ActiveRecord::Base === id
 
-      record = where(primary_key.eq(id)).first
+      if IdentityMap.enabled? && where_values.blank? &&
+        limit_value.blank? && order_values.blank? &&
+        includes_values.blank? && preload_values.blank? &&
+        readonly_value.nil? && joins_values.blank? &&
+        !@klass.locking_enabled? &&
+        record = IdentityMap.get(@klass, id)
+        return record
+      end
+
+      column = columns_hash[primary_key]
+
+      substitute = connection.substitute_at(column, @bind_values.length)
+      relation = where(table[primary_key].eq(substitute))
+      relation.bind_values = [[column, id]]
+      record = relation.first
 
       unless record
         conditions = arel.where_sql
         conditions = " [#{conditions}]" if conditions
-        raise RecordNotFound, "Couldn't find #{@klass.name} with ID=#{id}#{conditions}"
+        raise RecordNotFound, "Couldn't find #{@klass.name} with #{primary_key}=#{id}#{conditions}"
       end
 
       record
     end
 
     def find_some(ids)
-      result = where(primary_key.in(ids)).all
+      result = where(table[primary_key].in(ids)).all
 
       expected_size =
         if @limit_value && ids.size > @limit_value
@@ -327,8 +354,8 @@ module ActiveRecord
       if result.size == expected_size
         result
       else
-        conditions = arel.wheres.map { |x| x.value }.join(', ')
-        conditions = " [WHERE #{conditions}]" if conditions.present?
+        conditions = arel.where_sql
+        conditions = " [#{conditions}]" if conditions
 
         error = "Couldn't find all #{@klass.name.pluralize} with IDs "
         error << "(#{ids.join(", ")})#{conditions} (found #{result.size} results, but was looking for #{expected_size})"
@@ -352,14 +379,8 @@ module ActiveRecord
       end
     end
 
-    def column_aliases(join_dependency)
-      join_dependency.joins.collect{|join| join.column_names_with_alias.collect{|column_name, aliased_name|
-          "#{connection.quote_table_name join.aliased_table_name}.#{connection.quote_column_name column_name} AS #{aliased_name}"}}.flatten.join(", ")
-    end
-
     def using_limitable_reflections?(reflections)
       reflections.none? { |r| r.collection? }
     end
-
   end
 end

data/lib/active_record/relation/predicate_builder.rb

@@ -1,38 +1,42 @@
 module ActiveRecord
-  class PredicateBuilder
-
-    def initialize(engine)
-      @engine = engine
-    end
-
-    def build_from_hash(attributes, default_table, allow_table_name = true)
+  class PredicateBuilder # :nodoc:
+    def self.build_from_hash(engine, attributes, default_table)
       predicates = attributes.map do |column, value|
         table = default_table
 
-        if allow_table_name && value.is_a?(Hash)
-          table = Arel::Table.new(column, :engine => @engine)
-
-          if value.empty?
-            '1 = 2'
-          else
-            build_from_hash(value, table, false)
-          end
+        if value.is_a?(Hash)
+          table = Arel::Table.new(column, engine)
+          build_from_hash(engine, value, table)
         else
           column = column.to_s
 
-          if allow_table_name && column.include?('.')
+          if column.include?('.')
             table_name, column = column.split('.', 2)
-            table = Arel::Table.new(table_name, :engine => @engine)
+            table = Arel::Table.new(table_name, engine)
           end
 
-          attribute = table[column] || Arel::Attribute.new(table, column)
+          attribute = table[column.to_sym]
 
           case value
-          when Array, ActiveRecord::Associations::AssociationCollection, ActiveRecord::Relation
+          when ActiveRecord::Relation
+            value.select_values = [value.klass.arel_table['id']] if value.select_values.empty?
+            attribute.in(value.arel.ast)
+          when Array, ActiveRecord::Associations::CollectionProxy
             values = value.to_a.map { |x|
               x.is_a?(ActiveRecord::Base) ? x.id : x
             }
-            attribute.in(values)
+
+            if values.include?(nil)
+              values = values.compact
+              if values.empty?
+                attribute.eq nil
+              else
+                attribute.in(values.compact).or attribute.eq(nil)
+              end
+            else
+              attribute.in(values)
+            end
+
           when Range, Arel::Relation
             attribute.in(value)
           when ActiveRecord::Base
@@ -48,6 +52,5 @@ module ActiveRecord
 
       predicates.flatten
     end
-
   end
 end

data/lib/active_record/relation/query_methods.rb

@@ -6,13 +6,15 @@ module ActiveRecord
     extend ActiveSupport::Concern
 
     attr_accessor :includes_values, :eager_load_values, :preload_values,
-                  :select_values, :group_values, :order_values, :reorder_flag, :joins_values, :where_values, :having_values,
-                  :limit_value, :offset_value, :lock_value, :readonly_value, :create_with_value, :from_value
+                  :select_values, :group_values, :order_values, :joins_values,
+                  :where_values, :having_values, :bind_values,
+                  :limit_value, :offset_value, :lock_value, :readonly_value, :create_with_value,
+                  :from_value, :reorder_value
 
     def includes(*args)
       args.reject! {|a| a.blank? }
 
-      return clone if args.empty?
+      return self if args.empty?
 
       relation = clone
       relation.includes_values = (relation.includes_values + args).flatten.uniq
@@ -20,14 +22,18 @@ module ActiveRecord
     end
 
     def eager_load(*args)
+      return self if args.blank?
+
       relation = clone
-      relation.eager_load_values += args unless args.blank?
+      relation.eager_load_values += args
       relation
     end
 
     def preload(*args)
+      return self if args.blank?
+
       relation = clone
-      relation.preload_values += args unless args.blank?
+      relation.preload_values += args
       relation
     end
 
@@ -42,44 +48,59 @@ module ActiveRecord
     end
 
     def group(*args)
+      return self if args.blank?
+
       relation = clone
-      relation.group_values += args.flatten unless args.blank?
+      relation.group_values += args.flatten
       relation
     end
 
     def order(*args)
+      return self if args.blank?
+
       relation = clone
-      relation.order_values += args.flatten unless args.blank?
+      relation.order_values += args.flatten
       relation
     end
 
     def reorder(*args)
+      return self if args.blank?
+
       relation = clone
-      unless args.blank?
-        relation.order_values = args
-        relation.reorder_flag = true
-      end
+      relation.reorder_value = args.flatten
       relation
     end
 
     def joins(*args)
+      return self if args.compact.blank?
+
       relation = clone
 
       args.flatten!
-      relation.joins_values += args unless args.blank?
+      relation.joins_values += args
 
       relation
     end
 
+    def bind(value)
+      relation = clone
+      relation.bind_values += [value]
+      relation
+    end
+
     def where(opts, *rest)
+      return self if opts.blank?
+
       relation = clone
-      relation.where_values += build_where(opts, rest) unless opts.blank?
+      relation.where_values += build_where(opts, rest)
       relation
     end
 
     def having(*args)
+      return self if args.blank?
+
       relation = clone
-      relation.having_values += build_where(*args) unless args.blank?
+      relation.having_values += build_where(*args)
       relation
     end
 
@@ -116,7 +137,7 @@ module ActiveRecord
 
     def create_with(value)
       relation = clone
-      relation.create_with_value = value
+      relation.create_with_value = value && (@create_with_value || {}).merge(value)
       relation
     end
 
@@ -126,8 +147,10 @@ module ActiveRecord
       relation
     end
 
-    def extending(*modules, &block)
-      modules << Module.new(&block) if block_given?
+    def extending(*modules)
+      modules << Module.new(&Proc.new) if block_given?
+
+      return self if modules.empty?
 
       relation = clone
       relation.send(:apply_modules, modules.flatten)
@@ -135,86 +158,73 @@ module ActiveRecord
     end
 
     def reverse_order
-      order_clause = arel.order_clauses.join(', ')
-      relation = except(:order)
+      order_clause = arel.order_clauses
 
-      order = order_clause.blank? ?
-        "#{@klass.table_name}.#{@klass.primary_key} DESC" :
-        reverse_sql_order(order_clause)
+      order = order_clause.empty? ?
+        "#{table_name}.#{primary_key} DESC" :
+        reverse_sql_order(order_clause).join(', ')
 
-      relation.order(Arel.sql(order))
+      except(:order).order(Arel.sql(order))
     end
 
     def arel
-      @arel ||= build_arel
-    end
-
-    def custom_join_sql(*joins)
-      arel = table.select_manager
-
-      joins.each do |join|
-        next if join.blank?
-
-        @implicit_readonly = true
-
-        case join
-        when Array
-          join = Arel.sql(join.join(' ')) if array_of_strings?(join)
-        when String
-          join = Arel.sql(join)
-        end
-
-        arel.join(join)
-      end
-
-      arel.join_sql
+      @arel ||= with_default_scope.build_arel
     end
 
     def build_arel
-      arel = table
+      arel = table.from table
 
-      arel = build_joins(arel, @joins_values) unless @joins_values.empty?
+      build_joins(arel, @joins_values) unless @joins_values.empty?
 
-      arel = collapse_wheres(arel, (@where_values - ['']).uniq)
+      collapse_wheres(arel, (@where_values - ['']).uniq)
 
-      arel = arel.having(*@having_values.uniq.reject{|h| h.blank?}) unless @having_values.empty?
+      arel.having(*@having_values.uniq.reject{|h| h.blank?}) unless @having_values.empty?
 
-      arel = arel.take(connection.sanitize_limit(@limit_value)) if @limit_value
-      arel = arel.skip(@offset_value) if @offset_value
+      arel.take(connection.sanitize_limit(@limit_value)) if @limit_value
+      arel.skip(@offset_value) if @offset_value
 
-      arel = arel.group(*@group_values.uniq.reject{|g| g.blank?}) unless @group_values.empty?
+      arel.group(*@group_values.uniq.reject{|g| g.blank?}) unless @group_values.empty?
 
-      arel = arel.order(*@order_values.uniq.reject{|o| o.blank?}) unless @order_values.empty?
+      order = @reorder_value ? @reorder_value : @order_values
+      arel.order(*order.uniq.reject{|o| o.blank?}) unless order.empty?
 
-      arel = build_select(arel, @select_values.uniq)
+      build_select(arel, @select_values.uniq)
 
-      arel = arel.from(@from_value) if @from_value
-      arel = arel.lock(@lock_value) if @lock_value
+      arel.from(@from_value) if @from_value
+      arel.lock(@lock_value) if @lock_value
 
       arel
     end
 
     private
 
-    def collapse_wheres(arel, wheres)
-      equalities = wheres.grep(Arel::Nodes::Equality)
+    def custom_join_ast(table, joins)
+      joins = joins.reject { |join| join.blank? }
 
-      groups = equalities.group_by do |equality|
-        equality.left
-      end
+      return [] if joins.empty?
 
-      groups.each do |_, eqls|
-        test = eqls.inject(eqls.shift) do |memo, expr|
-          memo.and(expr)
+      @implicit_readonly = true
+
+      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
-        arel = arel.where(test)
+        table.create_string_join(join)
       end
+    end
+
+    def collapse_wheres(arel, wheres)
+      equalities = wheres.grep(Arel::Nodes::Equality)
+
+      arel.where(Arel::Nodes::And.new(equalities)) unless equalities.empty?
 
       (wheres - equalities).each do |where|
         where = Arel.sql(where) if String === where
-        arel = arel.where(Arel::Nodes::Grouping.new(where))
+        arel.where(Arel::Nodes::Grouping.new(where))
       end
-      arel
     end
 
     def build_where(opts, other = [])
@@ -223,48 +233,60 @@ module ActiveRecord
         [@klass.send(:sanitize_sql, other.empty? ? opts : ([opts] + other))]
       when Hash
         attributes = @klass.send(:expand_hash_conditions_for_aggregates, opts)
-        PredicateBuilder.new(table.engine).build_from_hash(attributes, table)
+        PredicateBuilder.build_from_hash(table.engine, attributes, table)
       else
         [opts]
       end
     end
 
-    def build_joins(relation, joins)
-      association_joins = []
-
-      joins = @joins_values.map {|j| j.respond_to?(:strip) ? j.strip : j}.uniq
-
-      joins.each do |join|
-        association_joins << join if [Hash, Array, Symbol].include?(join.class) && !array_of_strings?(join)
+    def build_joins(manager, joins)
+      buckets = joins.group_by do |join|
+        case join
+        when String
+          'string_join'
+        when Hash, Symbol, Array
+          'association_join'
+        when ActiveRecord::Associations::JoinDependency::JoinAssociation
+          'stashed_join'
+        when Arel::Nodes::Join
+          'join_node'
+        else
+          raise 'unknown class: %s' % join.class.name
+        end
       end
 
-      stashed_association_joins = joins.grep(ActiveRecord::Associations::ClassMethods::JoinDependency::JoinAssociation)
+      association_joins         = buckets['association_join'] || []
+      stashed_association_joins = buckets['stashed_join'] || []
+      join_nodes                = buckets['join_node'] || []
+      string_joins              = (buckets['string_join'] || []).map { |x|
+        x.strip
+      }.uniq
+
+      join_list = custom_join_ast(manager, string_joins)
 
-      non_association_joins = (joins - association_joins - stashed_association_joins)
-      custom_joins = custom_join_sql(*non_association_joins)
+      join_dependency = ActiveRecord::Associations::JoinDependency.new(
+        @klass,
+        association_joins,
+        join_list
+      )
 
-      join_dependency = ActiveRecord::Associations::ClassMethods::JoinDependency.new(@klass, association_joins, custom_joins)
+      join_nodes.each do |join|
+        join_dependency.alias_tracker.aliased_name_for(join.left.name.downcase)
+      end
 
       join_dependency.graft(*stashed_association_joins)
 
       @implicit_readonly = true unless association_joins.empty? && stashed_association_joins.empty?
 
-      to_join = []
-
+      # FIXME: refactor this to build an AST
       join_dependency.join_associations.each do |association|
-        if (association_relation = association.relation).is_a?(Array)
-          to_join << [association_relation.first, association.join_type, association.association_join.first]
-          to_join << [association_relation.last, association.join_type, association.association_join.last]
-        else
-          to_join << [association_relation, association.join_type, association.association_join]
-        end
+        association.join_to(manager)
       end
 
-      to_join.uniq.each do |left, join_type, right|
-        relation = relation.join(left, join_type).on(*right)
-      end
+      manager.join_sources.concat join_nodes.uniq
+      manager.join_sources.concat join_list
 
-      relation.join(custom_joins)
+      manager
     end
 
     def build_select(arel, selects)
@@ -272,7 +294,7 @@ module ActiveRecord
         @implicit_readonly = false
         arel.project(*selects)
       else
-        arel.project(Arel::SqlLiteral.new(@klass.quoted_table_name + '.*'))
+        arel.project(@klass.arel_table[Arel.star])
       end
     end
 
@@ -284,15 +306,9 @@ module ActiveRecord
     end
 
     def reverse_sql_order(order_query)
-      order_query.to_s.split(/,/).each { |s|
-        if s.match(/\s(asc|ASC)$/)
-          s.gsub!(/\s(asc|ASC)$/, ' DESC')
-        elsif s.match(/\s(desc|DESC)$/)
-          s.gsub!(/\s(desc|DESC)$/, ' ASC')
-        else
-          s.concat(' DESC')
-        end
-      }.join(',')
+      order_query.join(', ').split(',').collect do |s|
+        s.gsub!(/\sasc\Z/i, ' DESC') || s.gsub!(/\sdesc\Z/i, ' ASC') || s.concat(' DESC')
+      end
     end
 
     def array_of_strings?(o)