activerecord 6.0.0.beta1 → 6.0.0

data/lib/active_record/querying.rb

@@ -2,18 +2,23 @@
 
 module ActiveRecord
   module Querying
-    delegate :find, :take, :take!, :first, :first!, :last, :last!, :exists?, :any?, :many?, :none?, :one?, to: :all
-    delegate :second, :second!, :third, :third!, :fourth, :fourth!, :fifth, :fifth!, :forty_two, :forty_two!, :third_to_last, :third_to_last!, :second_to_last, :second_to_last!, to: :all
-    delegate :first_or_create, :first_or_create!, :first_or_initialize, to: :all
-    delegate :find_or_create_by, :find_or_create_by!, :create_or_find_by, :create_or_find_by!, :find_or_initialize_by, to: :all
-    delegate :find_by, :find_by!, to: :all
-    delegate :destroy_all, :delete_all, :update_all, to: :all
-    delegate :find_each, :find_in_batches, :in_batches, to: :all
-    delegate :select, :group, :order, :except, :reorder, :limit, :offset, :joins, :left_joins, :left_outer_joins, :or,
-             :where, :rewhere, :preload, :eager_load, :includes, :from, :lock, :readonly, :extending,
-             :having, :create_with, :distinct, :references, :none, :unscope, :merge, to: :all
-    delegate :count, :average, :minimum, :maximum, :sum, :calculate, to: :all
-    delegate :pluck, :pick, :ids, to: :all
+    QUERYING_METHODS = [
+      :find, :find_by, :find_by!, :take, :take!, :first, :first!, :last, :last!,
+      :second, :second!, :third, :third!, :fourth, :fourth!, :fifth, :fifth!,
+      :forty_two, :forty_two!, :third_to_last, :third_to_last!, :second_to_last, :second_to_last!,
+      :exists?, :any?, :many?, :none?, :one?,
+      :first_or_create, :first_or_create!, :first_or_initialize,
+      :find_or_create_by, :find_or_create_by!, :find_or_initialize_by,
+      :create_or_find_by, :create_or_find_by!,
+      :destroy_all, :delete_all, :update_all, :touch_all, :destroy_by, :delete_by,
+      :find_each, :find_in_batches, :in_batches,
+      :select, :reselect, :order, :reorder, :group, :limit, :offset, :joins, :left_joins, :left_outer_joins,
+      :where, :rewhere, :preload, :extract_associated, :eager_load, :includes, :from, :lock, :readonly, :extending, :or,
+      :having, :create_with, :distinct, :references, :none, :unscope, :optimizer_hints, :merge, :except, :only,
+      :count, :average, :minimum, :maximum, :sum, :calculate, :annotate,
+      :pluck, :pick, :ids
+    ].freeze # :nodoc:
+    delegate(*QUERYING_METHODS, to: :all)
 
     # Executes a custom SQL query against your database and returns all the results. The results will
     # be returned as an array, with the requested columns encapsulated as attributes of the model you call
@@ -40,8 +45,7 @@ module ActiveRecord
     def find_by_sql(sql, binds = [], preparable: nil, &block)
       result_set = connection.select_all(sanitize_sql(sql), "#{name} Load", binds, preparable: preparable)
       column_types = result_set.column_types.dup
-      cached_columns_hash = connection.schema_cache.columns_hash(table_name)
-      cached_columns_hash.each_key { |k| column_types.delete k }
+      attribute_types.each_key { |k| column_types.delete k }
       message_bus = ActiveSupport::Notifications.instrumenter
 
       payload = {

data/lib/active_record/railtie.rb

@@ -88,6 +88,14 @@ module ActiveRecord
       end
     end
 
+    initializer "active_record.database_selector" do
+      if options = config.active_record.delete(:database_selector)
+        resolver = config.active_record.delete(:database_resolver)
+        operations = config.active_record.delete(:database_resolver_context)
+        config.app_middleware.use ActiveRecord::Middleware::DatabaseSelector, resolver, operations, options
+      end
+    end
+
     initializer "Check for cache versioning support" do
       config.after_initialize do |app|
         ActiveSupport.on_load(:active_record) do
@@ -126,7 +134,6 @@ end_error
 
               cache = YAML.load(File.read(filename))
               if cache.version == current_version
-                connection.schema_cache = cache
                 connection_pool.schema_cache = cache.dup
               else
                 warn "Ignoring db/schema_cache.yml because it has expired. The current schema version is #{current_version}, but the one in the cache is #{cache.version}."
@@ -189,6 +196,7 @@ end_error
     # and then establishes the connection.
     initializer "active_record.initialize_database" do
       ActiveSupport.on_load(:active_record) do
+        self.connection_handlers = { writing_role => ActiveRecord::Base.default_connection_handler }
         self.configurations = Rails.application.config.database_configuration
         establish_connection
       end

data/lib/active_record/railties/collection_cache_association_loading.rb

@@ -3,7 +3,7 @@
 module ActiveRecord
   module Railties # :nodoc:
     module CollectionCacheAssociationLoading #:nodoc:
-      def setup(context, options, block)
+      def setup(context, options, as, block)
         @relation = relation_from_options(options)
 
         super
@@ -20,12 +20,12 @@ module ActiveRecord
         end
       end
 
-      def collection_without_template
+      def collection_without_template(*)
         @relation.preload_associations(@collection) if @relation
         super
       end
 
-      def collection_with_template
+      def collection_with_template(*)
         @relation.preload_associations(@collection) if @relation
         super
       end

data/lib/active_record/railties/databases.rake

@@ -2,6 +2,8 @@
 
 require "active_record"
 
+databases = ActiveRecord::Tasks::DatabaseTasks.setup_initial_database_yaml
+
 db_namespace = namespace :db do
   desc "Set the environment value for the database"
   task "environment:set" => :load_config do
@@ -23,7 +25,7 @@ db_namespace = namespace :db do
       ActiveRecord::Tasks::DatabaseTasks.create_all
     end
 
-    ActiveRecord::Tasks::DatabaseTasks.for_each do |spec_name|
+    ActiveRecord::Tasks::DatabaseTasks.for_each(databases) do |spec_name|
       desc "Create #{spec_name} database for current environment"
       task spec_name => :load_config do
         db_config = ActiveRecord::Base.configurations.configs_for(env_name: Rails.env, spec_name: spec_name)
@@ -42,7 +44,7 @@ db_namespace = namespace :db do
       ActiveRecord::Tasks::DatabaseTasks.drop_all
     end
 
-    ActiveRecord::Tasks::DatabaseTasks.for_each do |spec_name|
+    ActiveRecord::Tasks::DatabaseTasks.for_each(databases) do |spec_name|
       desc "Drop #{spec_name} database for current environment"
       task spec_name => [:load_config, :check_protected_environments] do
         db_config = ActiveRecord::Base.configurations.configs_for(env_name: Rails.env, spec_name: spec_name)
@@ -66,6 +68,11 @@ db_namespace = namespace :db do
     end
   end
 
+  # desc "Truncates tables of each database for current environment"
+  task truncate_all: [:load_config, :check_protected_environments] do
+    ActiveRecord::Tasks::DatabaseTasks.truncate_all
+  end
+
   # desc "Empty the database from DATABASE_URL or config/database.yml for the current RAILS_ENV (use db:purge:all to purge all databases in the config). Without RAILS_ENV it defaults to purging the development and test databases."
   task purge: [:load_config, :check_protected_environments] do
     ActiveRecord::Tasks::DatabaseTasks.purge_current
@@ -73,7 +80,7 @@ db_namespace = namespace :db do
 
   desc "Migrate the database (options: VERSION=x, VERBOSE=false, SCOPE=blog)."
   task migrate: :load_config do
-    ActiveRecord::Base.configurations.configs_for(env_name: Rails.env).each do |db_config|
+    ActiveRecord::Base.configurations.configs_for(env_name: ActiveRecord::Tasks::DatabaseTasks.env).each do |db_config|
       ActiveRecord::Base.establish_connection(db_config.config)
       ActiveRecord::Tasks::DatabaseTasks.migrate
     end
@@ -96,7 +103,7 @@ db_namespace = namespace :db do
   end
 
   namespace :migrate do
-    ActiveRecord::Tasks::DatabaseTasks.for_each do |spec_name|
+    ActiveRecord::Tasks::DatabaseTasks.for_each(databases) do |spec_name|
       desc "Migrate #{spec_name} database for current environment"
       task spec_name => :load_config do
         db_config = ActiveRecord::Base.configurations.configs_for(env_name: Rails.env, spec_name: spec_name)
@@ -123,6 +130,8 @@ db_namespace = namespace :db do
 
     # desc 'Runs the "up" for a given migration VERSION.'
     task up: :load_config do
+      ActiveRecord::Tasks::DatabaseTasks.raise_for_multi_db(command: "db:migrate:up")
+
       raise "VERSION is required" if !ENV["VERSION"] || ENV["VERSION"].empty?
 
       ActiveRecord::Tasks::DatabaseTasks.check_target_version
@@ -134,8 +143,29 @@ db_namespace = namespace :db do
       db_namespace["_dump"].invoke
     end
 
+    namespace :up do
+      ActiveRecord::Tasks::DatabaseTasks.for_each(databases) do |spec_name|
+        task spec_name => :load_config do
+          raise "VERSION is required" if !ENV["VERSION"] || ENV["VERSION"].empty?
+
+          db_config = ActiveRecord::Base.configurations.configs_for(env_name: Rails.env, spec_name: spec_name)
+
+          ActiveRecord::Base.establish_connection(db_config.config)
+          ActiveRecord::Tasks::DatabaseTasks.check_target_version
+          ActiveRecord::Base.connection.migration_context.run(
+            :up,
+            ActiveRecord::Tasks::DatabaseTasks.target_version
+          )
+
+          db_namespace["_dump"].invoke
+        end
+      end
+    end
+
     # desc 'Runs the "down" for a given migration VERSION.'
     task down: :load_config do
+      ActiveRecord::Tasks::DatabaseTasks.raise_for_multi_db(command: "db:migrate:down")
+
       raise "VERSION is required - To go down one migration, use db:rollback" if !ENV["VERSION"] || ENV["VERSION"].empty?
 
       ActiveRecord::Tasks::DatabaseTasks.check_target_version
@@ -147,16 +177,35 @@ db_namespace = namespace :db do
       db_namespace["_dump"].invoke
     end
 
+    namespace :down do
+      ActiveRecord::Tasks::DatabaseTasks.for_each(databases) do |spec_name|
+        task spec_name => :load_config do
+          raise "VERSION is required" if !ENV["VERSION"] || ENV["VERSION"].empty?
+
+          db_config = ActiveRecord::Base.configurations.configs_for(env_name: Rails.env, spec_name: spec_name)
+
+          ActiveRecord::Base.establish_connection(db_config.config)
+          ActiveRecord::Tasks::DatabaseTasks.check_target_version
+          ActiveRecord::Base.connection.migration_context.run(
+            :down,
+            ActiveRecord::Tasks::DatabaseTasks.target_version
+          )
+
+          db_namespace["_dump"].invoke
+        end
+      end
+    end
+
     desc "Display status of migrations"
     task status: :load_config do
-      ActiveRecord::Base.configurations.configs_for(env_name: Rails.env).each do |db_config|
+      ActiveRecord::Base.configurations.configs_for(env_name: ActiveRecord::Tasks::DatabaseTasks.env).each do |db_config|
         ActiveRecord::Base.establish_connection(db_config.config)
         ActiveRecord::Tasks::DatabaseTasks.migrate_status
       end
     end
 
     namespace :status do
-      ActiveRecord::Tasks::DatabaseTasks.for_each do |spec_name|
+      ActiveRecord::Tasks::DatabaseTasks.for_each(databases) do |spec_name|
         desc "Display status of migrations for #{spec_name} database"
         task spec_name => :load_config do
           db_config = ActiveRecord::Base.configurations.configs_for(env_name: Rails.env, spec_name: spec_name)
@@ -203,7 +252,11 @@ db_namespace = namespace :db do
 
   # desc "Raises an error if there are pending migrations"
   task abort_if_pending_migrations: :load_config do
-    pending_migrations = ActiveRecord::Base.connection.migration_context.open.pending_migrations
+    pending_migrations = ActiveRecord::Base.configurations.configs_for(env_name: ActiveRecord::Tasks::DatabaseTasks.env).flat_map do |db_config|
+      ActiveRecord::Base.establish_connection(db_config.config)
+
+      ActiveRecord::Base.connection.migration_context.open.pending_migrations
+    end
 
     if pending_migrations.any?
       puts "You have #{pending_migrations.size} pending #{pending_migrations.size > 1 ? 'migrations:' : 'migration:'}"
@@ -212,17 +265,74 @@ db_namespace = namespace :db do
       end
       abort %{Run `rails db:migrate` to update your database then try again.}
     end
+  ensure
+    ActiveRecord::Base.establish_connection(ActiveRecord::Tasks::DatabaseTasks.env.to_sym)
+  end
+
+  namespace :abort_if_pending_migrations do
+    ActiveRecord::Tasks::DatabaseTasks.for_each(databases) do |spec_name|
+      # desc "Raises an error if there are pending migrations for #{spec_name} database"
+      task spec_name => :load_config do
+        db_config = ActiveRecord::Base.configurations.configs_for(env_name: Rails.env, spec_name: spec_name)
+        ActiveRecord::Base.establish_connection(db_config.config)
+
+        pending_migrations = ActiveRecord::Base.connection.migration_context.open.pending_migrations
+
+        if pending_migrations.any?
+          puts "You have #{pending_migrations.size} pending #{pending_migrations.size > 1 ? 'migrations:' : 'migration:'}"
+          pending_migrations.each do |pending_migration|
+            puts "  %4d %s" % [pending_migration.version, pending_migration.name]
+          end
+          abort %{Run `rails db:migrate:#{spec_name}` to update your database then try again.}
+        end
+      end
+    end
   end
 
   desc "Creates the database, loads the schema, and initializes with the seed data (use db:reset to also drop the database first)"
   task setup: ["db:schema:load_if_ruby", "db:structure:load_if_sql", :seed]
 
+  desc "Runs setup if database does not exist, or runs migrations if it does"
+  task prepare: :load_config do
+    seed = false
+
+    ActiveRecord::Base.configurations.configs_for(env_name: ActiveRecord::Tasks::DatabaseTasks.env).each do |db_config|
+      ActiveRecord::Base.establish_connection(db_config.config)
+
+      # Skipped when no database
+      ActiveRecord::Tasks::DatabaseTasks.migrate
+      if ActiveRecord::Base.dump_schema_after_migration
+        ActiveRecord::Tasks::DatabaseTasks.dump_schema(db_config.config, ActiveRecord::Base.schema_format, db_config.spec_name)
+      end
+
+    rescue ActiveRecord::NoDatabaseError
+      ActiveRecord::Tasks::DatabaseTasks.create_current(db_config.env_name, db_config.spec_name)
+      ActiveRecord::Tasks::DatabaseTasks.load_schema(
+        db_config.config,
+        ActiveRecord::Base.schema_format,
+        nil,
+        db_config.env_name,
+        db_config.spec_name
+      )
+
+      seed = true
+    end
+
+    ActiveRecord::Base.establish_connection
+    ActiveRecord::Tasks::DatabaseTasks.load_seed if seed
+  end
+
   desc "Loads the seed data from db/seeds.rb"
   task seed: :load_config do
     db_namespace["abort_if_pending_migrations"].invoke
     ActiveRecord::Tasks::DatabaseTasks.load_seed
   end
 
+  namespace :seed do
+    desc "Truncates tables of each database for current environment and loads the seeds"
+    task replant: [:load_config, :truncate_all, :seed]
+  end
+
   namespace :fixtures do
     desc "Loads fixtures into the current environment's database. Load specific fixtures using FIXTURES=x,y. Load from subdirectory in test/fixtures using FIXTURES_DIR=z. Specify an alternative path (eg. spec/fixtures) using FIXTURES_PATH=spec/fixtures."
     task load: :load_config do
@@ -274,13 +384,9 @@ db_namespace = namespace :db do
   namespace :schema do
     desc "Creates a db/schema.rb file that is portable against any DB supported by Active Record"
     task dump: :load_config do
-      require "active_record/schema_dumper"
-      ActiveRecord::Base.configurations.configs_for(env_name: Rails.env).each do |db_config|
-        filename = ActiveRecord::Tasks::DatabaseTasks.dump_filename(db_config.spec_name, :ruby)
-        File.open(filename, "w:utf-8") do |file|
-          ActiveRecord::Base.establish_connection(db_config.config)
-          ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection, file)
-        end
+      ActiveRecord::Base.configurations.configs_for(env_name: ActiveRecord::Tasks::DatabaseTasks.env).each do |db_config|
+        ActiveRecord::Base.establish_connection(db_config.config)
+        ActiveRecord::Tasks::DatabaseTasks.dump_schema(db_config.config, :ruby, db_config.spec_name)
       end
 
       db_namespace["schema:dump"].reenable
@@ -298,7 +404,7 @@ db_namespace = namespace :db do
     namespace :cache do
       desc "Creates a db/schema_cache.yml file."
       task dump: :load_config do
-        ActiveRecord::Base.configurations.configs_for(env_name: Rails.env).each do |db_config|
+        ActiveRecord::Base.configurations.configs_for(env_name: ActiveRecord::Tasks::DatabaseTasks.env).each do |db_config|
           ActiveRecord::Base.establish_connection(db_config.config)
           filename = ActiveRecord::Tasks::DatabaseTasks.cache_dump_filename(db_config.spec_name)
           ActiveRecord::Tasks::DatabaseTasks.dump_schema_cache(
@@ -310,7 +416,7 @@ db_namespace = namespace :db do
 
       desc "Clears a db/schema_cache.yml file."
       task clear: :load_config do
-        ActiveRecord::Base.configurations.configs_for(env_name: Rails.env).each do |db_config|
+        ActiveRecord::Base.configurations.configs_for(env_name: ActiveRecord::Tasks::DatabaseTasks.env).each do |db_config|
           filename = ActiveRecord::Tasks::DatabaseTasks.cache_dump_filename(db_config.spec_name)
           rm_f filename, verbose: false
         end
@@ -321,16 +427,9 @@ db_namespace = namespace :db do
   namespace :structure do
     desc "Dumps the database structure to db/structure.sql. Specify another file with SCHEMA=db/my_structure.sql"
     task dump: :load_config do
-      ActiveRecord::Base.configurations.configs_for(env_name: Rails.env).each do |db_config|
+      ActiveRecord::Base.configurations.configs_for(env_name: ActiveRecord::Tasks::DatabaseTasks.env).each do |db_config|
         ActiveRecord::Base.establish_connection(db_config.config)
-        filename = ActiveRecord::Tasks::DatabaseTasks.dump_filename(db_config.spec_name, :sql)
-        ActiveRecord::Tasks::DatabaseTasks.structure_dump(db_config.config, filename)
-        if ActiveRecord::SchemaMigration.table_exists?
-          File.open(filename, "a") do |f|
-            f.puts ActiveRecord::Base.connection.dump_schema_information
-            f.print "\n"
-          end
-        end
+        ActiveRecord::Tasks::DatabaseTasks.dump_schema(db_config.config, :sql, db_config.spec_name)
       end
 
       db_namespace["structure:dump"].reenable

data/lib/active_record/reflection.rb

@@ -21,12 +21,12 @@ module ActiveRecord
 
       def add_reflection(ar, name, reflection)
         ar.clear_reflections_cache
-        name = name.to_s
+        name = -name.to_s
         ar._reflections = ar._reflections.except(name).merge!(name => reflection)
       end
 
       def add_aggregate_reflection(ar, name, reflection)
-        ar.aggregate_reflections = ar.aggregate_reflections.merge(name.to_s => reflection)
+        ar.aggregate_reflections = ar.aggregate_reflections.merge(-name.to_s => reflection)
       end
 
       private
@@ -178,28 +178,24 @@ module ActiveRecord
         scope ? [scope] : []
       end
 
-      def build_join_constraint(table, foreign_table)
-        key         = join_keys.key
-        foreign_key = join_keys.foreign_key
-
-        constraint = table[key].eq(foreign_table[foreign_key])
-
-        if klass.finder_needs_type_condition?
-          table.create_and([constraint, klass.send(:type_condition, table)])
-        else
-          constraint
-        end
-      end
-
-      def join_scope(table, foreign_klass)
+      def join_scope(table, foreign_table, foreign_klass)
         predicate_builder = predicate_builder(table)
         scope_chain_items = join_scopes(table, predicate_builder)
         klass_scope       = klass_join_scope(table, predicate_builder)
 
+        key         = join_keys.key
+        foreign_key = join_keys.foreign_key
+
+        klass_scope.where!(table[key].eq(foreign_table[foreign_key]))
+
         if type
           klass_scope.where!(type => foreign_klass.polymorphic_name)
         end
 
+        if klass.finder_needs_type_condition?
+          klass_scope.where!(klass.send(:type_condition, table))
+        end
+
         scope_chain_items.inject(klass_scope, &:merge!)
       end
 
@@ -481,7 +477,7 @@ module ActiveRecord
       def check_preloadable!
         return unless scope
 
-        if scope.arity > 0
+        unless scope.arity == 0
           raise ArgumentError, <<-MSG.squish
             The association scope '#{name}' is instance dependent (the scope
             block takes an argument). Preloading instance dependent scopes is
@@ -612,21 +608,9 @@ module ActiveRecord
 
         # returns either +nil+ or the inverse association name that it finds.
         def automatic_inverse_of
-          return unless can_find_inverse_of_automatically?(self)
+          if can_find_inverse_of_automatically?(self)
+            inverse_name = ActiveSupport::Inflector.underscore(options[:as] || active_record.name.demodulize).to_sym
 
-          inverse_name_candidates =
-            if options[:as]
-              [options[:as]]
-            else
-              active_record_name = active_record.name.demodulize
-              [active_record_name, ActiveSupport::Inflector.pluralize(active_record_name)]
-            end
-
-          inverse_name_candidates.map! do |candidate|
-            ActiveSupport::Inflector.underscore(candidate).to_sym
-          end
-
-          inverse_name_candidates.detect do |inverse_name|
             begin
               reflection = klass._reflect_on_association(inverse_name)
             rescue NameError
@@ -635,7 +619,9 @@ module ActiveRecord
               reflection = false
             end
 
-            valid_inverse_reflection?(reflection)
+            if valid_inverse_reflection?(reflection)
+              return inverse_name
+            end
           end
         end
 

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)
@@ -186,11 +187,9 @@ module ActiveRecord
         relation = apply_join_dependency
         relation.pluck(*column_names)
       else
-        disallow_raw_sql!(column_names)
+        klass.disallow_raw_sql!(column_names)
         relation = spawn
-        relation.select_values = column_names.map { |cn|
-          @klass.has_attribute?(cn) || @klass.attribute_alias?(cn) ? arel_attribute(cn) : cn
-        }
+        relation.select_values = column_names
         result = skip_query_cache_if_necessary { klass.connection.select_all(relation.arel, nil) }
         result.cast_values(klass.attribute_types)
       end
@@ -223,7 +222,6 @@ module ActiveRecord
     end
 
     private
-
       def has_include?(column_name)
         eager_loading? || (includes_values.present? && column_name && column_name != :all)
       end
@@ -238,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
@@ -253,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
 
@@ -304,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(
@@ -367,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)
@@ -413,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