activerecord 6.0.0.beta2 → 6.0.2.rc1

data/lib/active_record/relation/calculations.rb

@@ -129,11 +129,12 @@ module ActiveRecord
         relation = apply_join_dependency
 
         if operation.to_s.downcase == "count"
-          relation.distinct!
-          # PostgreSQL: ORDER BY expressions must appear in SELECT list when using DISTINCT
-          if (column_name == :all || column_name.nil?) && select_values.empty?
-            relation.order_values = []
+          unless distinct_value || distinct_select?(column_name || select_for_count)
+            relation.distinct!
+            relation.select_values = [ klass.primary_key || table[Arel.star] ]
           end
+          # PostgreSQL: ORDER BY expressions must appear in SELECT list when using DISTINCT
+          relation.order_values = []
         end
 
         relation.calculate(operation, column_name)
@@ -221,7 +222,6 @@ module ActiveRecord
     end
 
     private
-
       def has_include?(column_name)
         eager_loading? || (includes_values.present? && column_name && column_name != :all)
       end
@@ -236,10 +236,12 @@ module ActiveRecord
         if operation == "count"
           column_name ||= select_for_count
           if column_name == :all
-            if distinct && (group_values.any? || select_values.empty? && order_values.empty?)
+            if !distinct
+              distinct = distinct_select?(select_for_count) if group_values.empty?
+            elsif group_values.any? || select_values.empty? && order_values.empty?
               column_name = primary_key
             end
-          elsif column_name.is_a?(::String) && /\bDISTINCT[\s(]/i.match?(column_name)
+          elsif distinct_select?(column_name)
             distinct = nil
           end
         end
@@ -251,13 +253,15 @@ module ActiveRecord
         end
       end
 
+      def distinct_select?(column_name)
+        column_name.is_a?(::String) && /\bDISTINCT[\s(]/i.match?(column_name)
+      end
+
       def aggregate_column(column_name)
         return column_name if Arel::Expressions === column_name
 
-        if @klass.has_attribute?(column_name) || @klass.attribute_alias?(column_name)
-          @klass.arel_attribute(column_name)
-        else
-          Arel.sql(column_name == :all ? "*" : column_name.to_s)
+        arel_column(column_name.to_s) do |name|
+          Arel.sql(column_name == :all ? "*" : name)
         end
       end
 
@@ -302,25 +306,22 @@ module ActiveRecord
       end
 
       def execute_grouped_calculation(operation, column_name, distinct) #:nodoc:
-        group_attrs = group_values
+        group_fields = group_values
 
-        if group_attrs.first.respond_to?(:to_sym)
-          association  = @klass._reflect_on_association(group_attrs.first)
-          associated   = group_attrs.size == 1 && association && association.belongs_to? # only count belongs_to associations
-          group_fields = Array(associated ? association.foreign_key : group_attrs)
-        else
-          group_fields = group_attrs
+        if group_fields.size == 1 && group_fields.first.respond_to?(:to_sym)
+          association  = klass._reflect_on_association(group_fields.first)
+          associated   = association && association.belongs_to? # only count belongs_to associations
+          group_fields = Array(association.foreign_key) if associated
         end
         group_fields = arel_columns(group_fields)
 
-        group_aliases = group_fields.map { |field| column_alias_for(field) }
+        group_aliases = group_fields.map { |field|
+          field = connection.visitor.compile(field) if Arel.arel_node?(field)
+          column_alias_for(field.to_s.downcase)
+        }
         group_columns = group_aliases.zip(group_fields)
 
-        if operation == "count" && column_name == :all
-          aggregate_alias = "count_all"
-        else
-          aggregate_alias = column_alias_for([operation, column_name].join(" "))
-        end
+        aggregate_alias = column_alias_for("#{operation} #{column_name.to_s.downcase}")
 
         select_values = [
           operation_over_aggregate_column(
@@ -365,25 +366,21 @@ module ActiveRecord
         end]
       end
 
-      # Converts the given keys to the value that the database adapter returns as
+      # Converts the given field to the value that the database adapter returns as
       # a usable column name:
       #
       #   column_alias_for("users.id")                 # => "users_id"
       #   column_alias_for("sum(id)")                  # => "sum_id"
       #   column_alias_for("count(distinct users.id)") # => "count_distinct_users_id"
       #   column_alias_for("count(*)")                 # => "count_all"
-      def column_alias_for(keys)
-        if keys.respond_to? :name
-          keys = "#{keys.relation.name}.#{keys.name}"
-        end
-
-        table_name = keys.to_s.downcase
-        table_name.gsub!(/\*/, "all")
-        table_name.gsub!(/\W+/, " ")
-        table_name.strip!
-        table_name.gsub!(/ +/, "_")
-
-        @klass.connection.table_alias_for(table_name)
+      def column_alias_for(field)
+        column_alias = +field
+        column_alias.gsub!(/\*/, "all")
+        column_alias.gsub!(/\W+/, " ")
+        column_alias.strip!
+        column_alias.gsub!(/ +/, "_")
+
+        connection.table_alias_for(column_alias)
       end
 
       def type_for(field, &block)
@@ -411,16 +408,17 @@ module ActiveRecord
 
       def build_count_subquery(relation, column_name, distinct)
         if column_name == :all
+          column_alias = Arel.star
           relation.select_values = [ Arel.sql(FinderMethods::ONE_AS_ONE) ] unless distinct
         else
           column_alias = Arel.sql("count_column")
           relation.select_values = [ aggregate_column(column_name).as(column_alias) ]
         end
 
-        subquery = relation.arel.as(Arel.sql("subquery_for_count"))
-        select_value = operation_over_aggregate_column(column_alias || Arel.star, "count", false)
+        subquery_alias = Arel.sql("subquery_for_count")
+        select_value = operation_over_aggregate_column(column_alias, "count", false)
 
-        Arel::SelectManager.new(subquery).project(select_value)
+        relation.build_subquery(subquery_alias, select_value)
       end
   end
 end

data/lib/active_record/relation/delegation.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "mutex_m"
+
 module ActiveRecord
   module Delegation # :nodoc:
     module DelegateCache # :nodoc:
@@ -31,6 +33,10 @@ module ActiveRecord
         super
       end
 
+      def generate_relation_method(method)
+        generated_relation_methods.generate_method(method)
+      end
+
       protected
         def include_relation_methods(delegate)
           superclass.include_relation_methods(delegate) unless base_class?
@@ -39,27 +45,35 @@ module ActiveRecord
 
       private
         def generated_relation_methods
-          @generated_relation_methods ||= Module.new.tap do |mod|
-            mod_name = "GeneratedRelationMethods"
-            const_set mod_name, mod
-            private_constant mod_name
+          @generated_relation_methods ||= GeneratedRelationMethods.new.tap do |mod|
+            const_set(:GeneratedRelationMethods, mod)
+            private_constant :GeneratedRelationMethods
           end
         end
+    end
+
+    class GeneratedRelationMethods < Module # :nodoc:
+      include Mutex_m
+
+      def generate_method(method)
+        synchronize do
+          return if method_defined?(method)
 
-        def generate_relation_method(method)
           if /\A[a-zA-Z_]\w*[!?]?\z/.match?(method)
-            generated_relation_methods.module_eval <<-RUBY, __FILE__, __LINE__ + 1
+            module_eval <<-RUBY, __FILE__, __LINE__ + 1
               def #{method}(*args, &block)
                 scoping { klass.#{method}(*args, &block) }
               end
             RUBY
           else
-            generated_relation_methods.define_method(method) do |*args, &block|
+            define_method(method) do |*args, &block|
               scoping { klass.public_send(method, *args, &block) }
             end
           end
         end
+      end
     end
+    private_constant :GeneratedRelationMethods
 
     extend ActiveSupport::Concern
 
@@ -78,39 +92,17 @@ module ActiveRecord
     module ClassSpecificRelation # :nodoc:
       extend ActiveSupport::Concern
 
-      included do
-        @delegation_mutex = Mutex.new
-      end
-
       module ClassMethods # :nodoc:
         def name
           superclass.name
         end
-
-        def delegate_to_scoped_klass(method)
-          @delegation_mutex.synchronize do
-            return if method_defined?(method)
-
-            if /\A[a-zA-Z_]\w*[!?]?\z/.match?(method)
-              module_eval <<-RUBY, __FILE__, __LINE__ + 1
-                def #{method}(*args, &block)
-                  scoping { @klass.#{method}(*args, &block) }
-                end
-              RUBY
-            else
-              define_method method do |*args, &block|
-                scoping { @klass.public_send(method, *args, &block) }
-              end
-            end
-          end
-        end
       end
 
       private
 
         def method_missing(method, *args, &block)
           if @klass.respond_to?(method)
-            self.class.delegate_to_scoped_klass(method)
+            @klass.generate_relation_method(method)
             scoping { @klass.public_send(method, *args, &block) }
           else
             super

data/lib/active_record/relation/finder_methods.rb

@@ -7,8 +7,8 @@ module ActiveRecord
     ONE_AS_ONE = "1 AS one"
 
     # Find by id - This can either be a specific id (1), a list of ids (1, 5, 6), or an array of ids ([5, 6, 10]).
-    # If one or more records can not be found for the requested ids, then RecordNotFound will be raised. If the primary key
-    # is an integer, find by id coerces its arguments using +to_i+.
+    # If one or more records cannot be found for the requested ids, then ActiveRecord::RecordNotFound will be raised.
+    # If the primary key is an integer, find by id coerces its arguments by using +to_i+.
     #
     #   Person.find(1)          # returns the object for ID = 1
     #   Person.find("1")        # returns the object for ID = 1
@@ -314,7 +314,7 @@ module ActiveRecord
 
       relation = construct_relation_for_exists(conditions)
 
-      skip_query_cache_if_necessary { connection.select_one(relation.arel, "#{name} Exists") } ? true : false
+      skip_query_cache_if_necessary { connection.select_one(relation.arel, "#{name} Exists?") } ? true : false
     end
 
     # This method is called whenever no records are found with either a single
@@ -355,7 +355,7 @@ module ActiveRecord
         conditions = sanitize_forbidden_attributes(conditions)
 
         if distinct_value && offset_value
-          relation = limit(1)
+          relation = except(:order).limit!(1)
         else
           relation = except(:select, :distinct, :order)._select!(ONE_AS_ONE).limit!(1)
         end
@@ -370,17 +370,22 @@ module ActiveRecord
         relation
       end
 
-      def construct_join_dependency(associations)
-        ActiveRecord::Associations::JoinDependency.new(
-          klass, table, associations
-        )
-      end
-
       def apply_join_dependency(eager_loading: group_values.empty?)
-        join_dependency = construct_join_dependency(eager_load_values + includes_values)
+        join_dependency = construct_join_dependency(
+          eager_load_values + includes_values, Arel::Nodes::OuterJoin
+        )
         relation = except(:includes, :eager_load, :preload).joins!(join_dependency)
 
-        if eager_loading && !using_limitable_reflections?(join_dependency.reflections)
+        if eager_loading && !(
+            using_limitable_reflections?(join_dependency.reflections) &&
+            using_limitable_reflections?(
+              construct_join_dependency(
+                select_association_list(joins_values).concat(
+                  select_association_list(left_outer_joins_values)
+                ), nil
+              ).reflections
+            )
+        )
           if has_limit_or_offset?
             limited_ids = limited_ids_for(relation)
             limited_ids.empty? ? relation.none! : relation.where!(primary_key => limited_ids)

data/lib/active_record/relation/merger.rb

@@ -117,16 +117,16 @@ module ActiveRecord
           if other.klass == relation.klass
             relation.joins!(*other.joins_values)
           else
-            joins_dependency = other.joins_values.map do |join|
+            associations, others = other.joins_values.partition do |join|
               case join
-              when Hash, Symbol, Array
-                other.send(:construct_join_dependency, join)
-              else
-                join
+              when Hash, Symbol, Array; true
               end
             end
 
-            relation.joins!(*joins_dependency)
+            join_dependency = other.construct_join_dependency(
+              associations, Arel::Nodes::InnerJoin
+            )
+            relation.joins!(join_dependency, *others)
           end
         end
 
@@ -136,16 +136,11 @@ module ActiveRecord
           if other.klass == relation.klass
             relation.left_outer_joins!(*other.left_outer_joins_values)
           else
-            joins_dependency = other.left_outer_joins_values.map do |join|
-              case join
-              when Hash, Symbol, Array
-                other.send(:construct_join_dependency, join)
-              else
-                join
-              end
-            end
-
-            relation.left_outer_joins!(*joins_dependency)
+            associations = other.left_outer_joins_values
+            join_dependency = other.construct_join_dependency(
+              associations, Arel::Nodes::OuterJoin
+            )
+            relation.joins!(join_dependency)
           end
         end
 

data/lib/active_record/relation/query_methods.rb

@@ -41,18 +41,42 @@ module ActiveRecord
       #
       #    User.where.not(name: %w(Ko1 Nobu))
       #    # SELECT * FROM users WHERE name NOT IN ('Ko1', 'Nobu')
-      #
-      #    User.where.not(name: "Jon", role: "admin")
-      #    # SELECT * FROM users WHERE name != 'Jon' AND role != 'admin'
       def not(opts, *rest)
         opts = sanitize_forbidden_attributes(opts)
 
         where_clause = @scope.send(:where_clause_factory).build(opts, rest)
 
         @scope.references!(PredicateBuilder.references(opts)) if Hash === opts
-        @scope.where_clause += where_clause.invert
+
+        if not_behaves_as_nor?(opts)
+          ActiveSupport::Deprecation.warn(<<~MSG.squish)
+            NOT conditions will no longer behave as NOR in Rails 6.1.
+            To continue using NOR conditions, NOT each conditions manually
+            (`#{
+              opts.flat_map { |key, value|
+                if value.is_a?(Hash) && value.size > 1
+                  value.map { |k, v| ".where.not(#{key.inspect} => { #{k.inspect} => ... })" }
+                else
+                  ".where.not(#{key.inspect} => ...)"
+                end
+              }.join
+            }`).
+          MSG
+          @scope.where_clause += where_clause.invert(:nor)
+        else
+          @scope.where_clause += where_clause.invert
+        end
+
         @scope
       end
+
+      private
+        def not_behaves_as_nor?(opts)
+          return false unless opts.is_a?(Hash)
+
+          opts.any? { |k, v| v.is_a?(Hash) && v.size > 1 } ||
+            opts.size > 1
+        end
     end
 
     FROZEN_EMPTY_ARRAY = [].freeze
@@ -67,11 +91,13 @@ module ActiveRecord
         end
       class_eval <<-CODE, __FILE__, __LINE__ + 1
         def #{method_name}                   # def includes_values
-          get_value(#{name.inspect})         #   get_value(:includes)
+          default = DEFAULT_VALUES[:#{name}] #   default = DEFAULT_VALUES[:includes]
+          @values.fetch(:#{name}, default)   #   @values.fetch(:includes, default)
         end                                  # end
 
         def #{method_name}=(value)           # def includes_values=(value)
-          set_value(#{name.inspect}, value)  #   set_value(:includes, value)
+          assert_mutability!                 #   assert_mutability!
+          @values[:#{name}] = value          #   @values[:includes] = value
         end                                  # end
       CODE
     end
@@ -100,7 +126,7 @@ module ActiveRecord
     #
     # === conditions
     #
-    # If you want to add conditions to your included models you'll have
+    # If you want to add string conditions to your included models, you'll have
     # to explicitly reference them. For example:
     #
     #   User.includes(:posts).where('posts.name = ?', 'example')
@@ -111,6 +137,12 @@ module ActiveRecord
     #
     # Note that #includes works with association names while #references needs
     # the actual table name.
+    #
+    # If you pass the conditions via hash, you don't need to call #references
+    # explicitly, as #where references the tables for you. For example, this
+    # will work correctly:
+    #
+    #   User.includes(:posts).where(posts: { name: 'example' })
     def includes(*args)
       check_if_method_has_arguments!(:includes, args)
       spawn.includes!(*args)
@@ -154,6 +186,19 @@ module ActiveRecord
       self
     end
 
+    # Extracts a named +association+ from the relation. The named association is first preloaded,
+    # then the individual association records are collected from the relation. Like so:
+    #
+    #   account.memberships.extract_associated(:user)
+    #   # => Returns collection of User records
+    #
+    # This is short-hand for:
+    #
+    #   account.memberships.preload(:user).collect(&:user)
+    def extract_associated(association)
+      preload(association).collect(&association)
+    end
+
     # Use to indicate that the given +table_names+ are referenced by an SQL string,
     # and should therefore be JOINed in any query rather than loaded separately.
     # This method only works in conjunction with #includes.
@@ -233,13 +278,31 @@ module ActiveRecord
     def _select!(*fields) # :nodoc:
       fields.reject!(&:blank?)
       fields.flatten!
-      fields.map! do |field|
-        klass.attribute_alias?(field) ? klass.attribute_alias(field).to_sym : field
-      end
       self.select_values += fields
       self
     end
 
+    # Allows you to change a previously set select statement.
+    #
+    #   Post.select(:title, :body)
+    #   # SELECT `posts`.`title`, `posts`.`body` FROM `posts`
+    #
+    #   Post.select(:title, :body).reselect(:created_at)
+    #   # SELECT `posts`.`created_at` FROM `posts`
+    #
+    # This is short-hand for <tt>unscope(:select).select(fields)</tt>.
+    # Note that we're unscoping the entire select statement.
+    def reselect(*args)
+      check_if_method_has_arguments!(:reselect, args)
+      spawn.reselect!(*args)
+    end
+
+    # Same as #reselect but operates on relation in-place instead of copying.
+    def reselect!(*args) # :nodoc:
+      self.select_values = args
+      self
+    end
+
     # Allows to specify a group attribute:
     #
     #   User.group(:name)
@@ -320,7 +383,7 @@ module ActiveRecord
 
     # Same as #reorder but operates on relation in-place instead of copying.
     def reorder!(*args) # :nodoc:
-      preprocess_order_args(args)
+      preprocess_order_args(args) unless args.all?(&:blank?)
 
       self.reordering_value = true
       self.order_values = args
@@ -328,8 +391,8 @@ module ActiveRecord
     end
 
     VALID_UNSCOPING_VALUES = Set.new([:where, :select, :group, :order, :lock,
-                                     :limit, :offset, :joins, :left_outer_joins,
-                                     :includes, :from, :readonly, :having])
+                                     :limit, :offset, :joins, :left_outer_joins, :annotate,
+                                     :includes, :from, :readonly, :having, :optimizer_hints])
 
     # Removes an unwanted relation that is already defined on a chain of relations.
     # This is useful when passing around chains of relations and would like to
@@ -380,7 +443,8 @@ module ActiveRecord
           if !VALID_UNSCOPING_VALUES.include?(scope)
             raise ArgumentError, "Called unscope() with invalid unscoping argument ':#{scope}'. Valid arguments are :#{VALID_UNSCOPING_VALUES.to_a.join(", :")}."
           end
-          set_value(scope, DEFAULT_VALUES[scope])
+          assert_mutability!
+          @values[scope] = DEFAULT_VALUES[scope]
         when Hash
           scope.each do |key, target_value|
             if key != :where
@@ -880,6 +944,29 @@ module ActiveRecord
       self
     end
 
+    # Specify optimizer hints to be used in the SELECT statement.
+    #
+    # Example (for MySQL):
+    #
+    #   Topic.optimizer_hints("MAX_EXECUTION_TIME(50000)", "NO_INDEX_MERGE(topics)")
+    #   # SELECT /*+ MAX_EXECUTION_TIME(50000) NO_INDEX_MERGE(topics) */ `topics`.* FROM `topics`
+    #
+    # Example (for PostgreSQL with pg_hint_plan):
+    #
+    #   Topic.optimizer_hints("SeqScan(topics)", "Parallel(topics 8)")
+    #   # SELECT /*+ SeqScan(topics) Parallel(topics 8) */ "topics".* FROM "topics"
+    def optimizer_hints(*args)
+      check_if_method_has_arguments!(:optimizer_hints, args)
+      spawn.optimizer_hints!(*args)
+    end
+
+    def optimizer_hints!(*args) # :nodoc:
+      args.flatten!
+
+      self.optimizer_hints_values |= args
+      self
+    end
+
     # Reverse the existing order clause on the relation.
     #
     #   User.order('name ASC').reverse_order # generated SQL has 'ORDER BY name DESC'
@@ -904,23 +991,47 @@ module ActiveRecord
       self
     end
 
+    # Adds an SQL comment to queries generated from this relation. For example:
+    #
+    #   User.annotate("selecting user names").select(:name)
+    #   # SELECT "users"."name" FROM "users" /* selecting user names */
+    #
+    #   User.annotate("selecting", "user", "names").select(:name)
+    #   # SELECT "users"."name" FROM "users" /* selecting */ /* user */ /* names */
+    #
+    # The SQL block comment delimiters, "/*" and "*/", will be added automatically.
+    def annotate(*args)
+      check_if_method_has_arguments!(:annotate, args)
+      spawn.annotate!(*args)
+    end
+
+    # Like #annotate, but modifies relation in place.
+    def annotate!(*args) # :nodoc:
+      self.annotate_values += args
+      self
+    end
+
     # Returns the Arel object associated with the relation.
     def arel(aliases = nil) # :nodoc:
       @arel ||= build_arel(aliases)
     end
 
-    private
-      # Returns a relation value with a given name
-      def get_value(name)
-        @values.fetch(name, DEFAULT_VALUES[name])
-      end
+    def construct_join_dependency(associations, join_type) # :nodoc:
+      ActiveRecord::Associations::JoinDependency.new(
+        klass, table, associations, join_type
+      )
+    end
+
+    protected
+      def build_subquery(subquery_alias, select_value) # :nodoc:
+        subquery = except(:optimizer_hints).arel.as(subquery_alias)
 
-      # Sets the relation value with the given name
-      def set_value(name, value)
-        assert_mutability!
-        @values[name] = value
+        Arel::SelectManager.new(subquery).project(select_value).tap do |arel|
+          arel.optimizer_hints(*optimizer_hints_values) unless optimizer_hints_values.empty?
+        end
       end
 
+    private
       def assert_mutability!
         raise ImmutableRelation if @loaded
         raise ImmutableRelation if defined?(@arel) && @arel
@@ -929,8 +1040,11 @@ module ActiveRecord
       def build_arel(aliases)
         arel = Arel::SelectManager.new(table)
 
-        aliases = build_joins(arel, joins_values.flatten, aliases) unless joins_values.empty?
-        build_left_outer_joins(arel, left_outer_joins_values.flatten, aliases) unless left_outer_joins_values.empty?
+        if !joins_values.empty?
+          build_joins(arel, joins_values.flatten, aliases)
+        elsif !left_outer_joins_values.empty?
+          build_left_outer_joins(arel, left_outer_joins_values.flatten, aliases)
+        end
 
         arel.where(where_clause.ast) unless where_clause.empty?
         arel.having(having_clause.ast) unless having_clause.empty?
@@ -956,9 +1070,11 @@ module ActiveRecord
 
         build_select(arel)
 
+        arel.optimizer_hints(*optimizer_hints_values) unless optimizer_hints_values.empty?
         arel.distinct(distinct_value)
         arel.from(build_from) unless from_clause.empty?
         arel.lock(lock_value) if lock_value
+        arel.comment(*annotate_values) unless annotate_values.empty?
 
         arel
       end
@@ -978,32 +1094,68 @@ module ActiveRecord
         end
       end
 
-      def build_left_outer_joins(manager, outer_joins, aliases)
-        buckets = outer_joins.group_by do |join|
-          case join
+      def select_association_list(associations)
+        result = []
+        associations.each do |association|
+          case association
           when Hash, Symbol, Array
-            :association_join
-          when ActiveRecord::Associations::JoinDependency
-            :stashed_join
+            result << association
           else
-            raise ArgumentError, "only Hash, Symbol and Array are allowed"
+            yield if block_given?
           end
         end
+        result
+      end
+
+      def valid_association_list(associations)
+        select_association_list(associations) do
+          raise ArgumentError, "only Hash, Symbol and Array are allowed"
+        end
+      end
 
+      def build_left_outer_joins(manager, outer_joins, aliases)
+        buckets = Hash.new { |h, k| h[k] = [] }
+        buckets[:association_join] = valid_association_list(outer_joins)
         build_join_query(manager, buckets, Arel::Nodes::OuterJoin, aliases)
       end
 
       def build_joins(manager, joins, aliases)
-        buckets = joins.group_by do |join|
+        buckets = Hash.new { |h, k| h[k] = [] }
+
+        unless left_outer_joins_values.empty?
+          left_joins = valid_association_list(left_outer_joins_values.flatten)
+          buckets[:stashed_join] << construct_join_dependency(left_joins, Arel::Nodes::OuterJoin)
+        end
+
+        if joins.last.is_a?(ActiveRecord::Associations::JoinDependency)
+          buckets[:stashed_join] << joins.pop if joins.last.base_klass == klass
+        end
+
+        joins.map! do |join|
+          if join.is_a?(String)
+            table.create_string_join(Arel.sql(join.strip)) unless join.blank?
+          else
+            join
+          end
+        end.delete_if(&:blank?).uniq!
+
+        while joins.first.is_a?(Arel::Nodes::Join)
+          join_node = joins.shift
+          if join_node.is_a?(Arel::Nodes::StringJoin) && !buckets[:stashed_join].empty?
+            buckets[:join_node] << join_node
+          else
+            buckets[:leading_join] << join_node
+          end
+        end
+
+        joins.each do |join|
           case join
-          when String
-            :string_join
           when Hash, Symbol, Array
-            :association_join
+            buckets[:association_join] << join
           when ActiveRecord::Associations::JoinDependency
-            :stashed_join
+            buckets[:stashed_join] << join
           when Arel::Nodes::Join
-            :join_node
+            buckets[:join_node] << join
           else
             raise "unknown class: %s" % join.class.name
           end
@@ -1013,31 +1165,21 @@ module ActiveRecord
       end
 
       def build_join_query(manager, buckets, join_type, aliases)
-        buckets.default = []
-
         association_joins = buckets[:association_join]
         stashed_joins     = buckets[:stashed_join]
-        join_nodes        = buckets[:join_node].uniq
-        string_joins      = buckets[:string_join].map(&:strip).uniq
-
-        join_list = join_nodes + convert_join_strings_to_ast(string_joins)
-        alias_tracker = alias_tracker(join_list, aliases)
-
-        join_dependency = construct_join_dependency(association_joins)
-
-        joins = join_dependency.join_constraints(stashed_joins, join_type, alias_tracker)
-        joins.each { |join| manager.from(join) }
+        leading_joins     = buckets[:leading_join]
+        join_nodes        = buckets[:join_node]
 
-        manager.join_sources.concat(join_list)
+        join_sources = manager.join_sources
+        join_sources.concat(leading_joins) unless leading_joins.empty?
 
-        alias_tracker.aliases
-      end
+        unless association_joins.empty? && stashed_joins.empty?
+          alias_tracker = alias_tracker(leading_joins + join_nodes, aliases)
+          join_dependency = construct_join_dependency(association_joins, join_type)
+          join_sources.concat(join_dependency.join_constraints(stashed_joins, alias_tracker))
+        end
 
-      def convert_join_strings_to_ast(joins)
-        joins
-          .flatten
-          .reject(&:blank?)
-          .map { |join| table.create_string_join(Arel.sql(join)) }
+        join_sources.concat(join_nodes) unless join_nodes.empty?
       end
 
       def build_select(arel)
@@ -1054,10 +1196,11 @@ module ActiveRecord
         columns.flat_map do |field|
           case field
           when Symbol
-            field = field.to_s
-            arel_column(field) { connection.quote_table_name(field) }
+            arel_column(field.to_s) do |attr_name|
+              connection.quote_table_name(attr_name)
+            end
           when String
-            arel_column(field) { field }
+            arel_column(field, &:itself)
           when Proc
             field.call
           else
@@ -1067,17 +1210,20 @@ module ActiveRecord
       end
 
       def arel_column(field)
-        field = klass.attribute_alias(field) if klass.attribute_alias?(field)
+        field = klass.attribute_aliases[field] || field
         from = from_clause.name || from_clause.value
 
-        if klass.columns_hash.key?(field) &&
-            (!from || from == table.name || from == connection.quote_table_name(table.name))
+        if klass.columns_hash.key?(field) && (!from || table_name_matches?(from))
           arel_attribute(field)
         else
-          yield
+          yield field
         end
       end
 
+      def table_name_matches?(from)
+        /(?:\A|(?<!FROM)\s)(?:\b#{table.name}\b|#{connection.quote_table_name(table.name)})(?!\.)/i.match?(from.to_s)
+      end
+
       def reverse_sql_order(order_query)
         if order_query.empty?
           return [arel_attribute(primary_key).desc] if primary_key
@@ -1093,7 +1239,7 @@ module ActiveRecord
             o.reverse
           when String
             if does_not_support_reverse?(o)
-              raise IrreversibleOrderError, "Order #{o.inspect} can not be reversed automatically"
+              raise IrreversibleOrderError, "Order #{o.inspect} cannot be reversed automatically"
             end
             o.split(",").map! do |s|
               s.strip!
@@ -1139,6 +1285,7 @@ module ActiveRecord
       end
 
       def preprocess_order_args(order_args)
+        order_args.reject!(&:blank?)
         order_args.map! do |arg|
           klass.sanitize_sql_for_order(arg)
         end
@@ -1146,7 +1293,7 @@ module ActiveRecord
 
         @klass.disallow_raw_sql!(
           order_args.flat_map { |a| a.is_a?(Hash) ? a.keys : a },
-          permit: AttributeMethods::ClassMethods::COLUMN_NAME_WITH_ORDER
+          permit: connection.column_name_with_order_matcher
         )
 
         validate_order_args(order_args)
@@ -1159,20 +1306,14 @@ module ActiveRecord
         order_args.map! do |arg|
           case arg
           when Symbol
-            arg = arg.to_s
-            arel_column(arg) {
-              Arel.sql(connection.quote_table_name(arg))
-            }.asc
+            order_column(arg.to_s).asc
           when Hash
             arg.map { |field, dir|
               case field
               when Arel::Nodes::SqlLiteral
                 field.send(dir.downcase)
               else
-                field = field.to_s
-                arel_column(field) {
-                  Arel.sql(connection.quote_table_name(field))
-                }.send(dir.downcase)
+                order_column(field.to_s).send(dir.downcase)
               end
             }
           else
@@ -1181,6 +1322,16 @@ module ActiveRecord
         end.flatten!
       end
 
+      def order_column(field)
+        arel_column(field) do |attr_name|
+          if attr_name == "count" && !group_values.empty?
+            arel_attribute(attr_name)
+          else
+            Arel.sql(connection.quote_table_name(attr_name))
+          end
+        end
+      end
+
       # Checks to make sure that the arguments are not blank. Note that if some
       # blank-like object were initially passed into the query method, then this
       # method will not raise an error.
@@ -1207,7 +1358,8 @@ module ActiveRecord
       def structurally_incompatible_values_for_or(other)
         values = other.values
         STRUCTURAL_OR_METHODS.reject do |method|
-          get_value(method) == values.fetch(method, DEFAULT_VALUES[method])
+          default = DEFAULT_VALUES[method]
+          @values.fetch(method, default) == values.fetch(method, default)
         end
       end