activerecord 4.0.4 → 4.1.16

data/lib/active_record/relation/calculations.rb

@@ -19,7 +19,17 @@ module ActiveRecord
     #
     #   Person.group(:city).count
     #   # => { 'Rome' => 5, 'Paris' => 3 }
+    #
+    # If +count+ is used with +select+, it will count the selected columns:
+    #
+    #   Person.select(:age).count
+    #   # => counts the number of different age values
+    #
+    # Note: not all valid +select+ expressions are valid +count+ expressions. The specifics differ
+    # between databases. In invalid cases, an error from the databsae is thrown.
     def count(column_name = nil, options = {})
+      # TODO: Remove options argument as soon we remove support to
+      # activerecord-deprecated_finders.
       column_name, options = nil, column_name if column_name.is_a?(Hash)
       calculate(:count, column_name, options)
     end
@@ -27,8 +37,10 @@ module ActiveRecord
     # Calculates the average value on a given column. Returns +nil+ if there's
     # no row. See +calculate+ for examples with options.
     #
-    #   Person.average('age') # => 35.8
+    #   Person.average(:age) # => 35.8
     def average(column_name, options = {})
+      # TODO: Remove options argument as soon we remove support to
+      # activerecord-deprecated_finders.
       calculate(:average, column_name, options)
     end
 
@@ -36,8 +48,10 @@ module ActiveRecord
     # with the same data type of the column, or +nil+ if there's no row. See
     # +calculate+ for examples with options.
     #
-    #   Person.minimum('age') # => 7
+    #   Person.minimum(:age) # => 7
     def minimum(column_name, options = {})
+      # TODO: Remove options argument as soon we remove support to
+      # activerecord-deprecated_finders.
       calculate(:minimum, column_name, options)
     end
 
@@ -45,8 +59,10 @@ module ActiveRecord
     # with the same data type of the column, or +nil+ if there's no row. See
     # +calculate+ for examples with options.
     #
-    #   Person.maximum('age') # => 93
+    #   Person.maximum(:age) # => 93
     def maximum(column_name, options = {})
+      # TODO: Remove options argument as soon we remove support to
+      # activerecord-deprecated_finders.
       calculate(:maximum, column_name, options)
     end
 
@@ -54,17 +70,9 @@ module ActiveRecord
     # with the same data type of the column, 0 if there's no row. See
     # +calculate+ for examples with options.
     #
-    #   Person.sum('age') # => 4562
+    #   Person.sum(:age) # => 4562
     def sum(*args)
-      if block_given?
-        ActiveSupport::Deprecation.warn(
-          "Calling #sum with a block is deprecated and will be removed in Rails 4.1. " \
-          "If you want to perform sum calculation over the array of elements, use `to_a.sum(&block)`."
-        )
-        self.to_a.sum(*args) {|*block_args| yield(*block_args)}
-      else
-        calculate(:sum, *args)
-      end
+      calculate(:sum, *args)
     end
 
     # This calculates aggregate values in the given column. Methods for count, sum, average,
@@ -99,19 +107,17 @@ module ActiveRecord
     #
     #   Person.sum("2 * age")
     def calculate(operation, column_name, options = {})
-      relation = with_default_scope
+      # TODO: Remove options argument as soon we remove support to
+      # activerecord-deprecated_finders.
+      if column_name.is_a?(Symbol) && attribute_alias?(column_name)
+        column_name = attribute_alias(column_name)
+      end
 
-      if relation.equal?(self)
-        if has_include?(column_name)
-          construct_relation_for_association_calculations.calculate(operation, column_name, options)
-        else
-          perform_calculation(operation, column_name, options)
-        end
+      if has_include?(column_name)
+        construct_relation_for_association_calculations.calculate(operation, column_name, options)
       else
-        relation.calculate(operation, column_name, options)
+        perform_calculation(operation, column_name, options)
       end
-    rescue ThrowResult
-      0
     end
 
     # Use <tt>pluck</tt> as a shortcut to select one or more attributes without
@@ -149,10 +155,10 @@ module ActiveRecord
     #
     def pluck(*column_names)
       column_names.map! do |column_name|
-        if column_name.is_a?(Symbol) && self.column_names.include?(column_name.to_s)
-          "#{connection.quote_table_name(table_name)}.#{connection.quote_column_name(column_name)}"
+        if column_name.is_a?(Symbol) && attribute_alias?(column_name)
+          attribute_alias(column_name)
         else
-          column_name
+          column_name.to_s
         end
       end
 
@@ -160,22 +166,23 @@ module ActiveRecord
         construct_relation_for_association_calculations.pluck(*column_names)
       else
         relation = spawn
-        relation.select_values = column_names
+        relation.select_values = column_names.map { |cn|
+          columns_hash.key?(cn) ? arel_table[cn] : cn
+        }
         result = klass.connection.select_all(relation.arel, nil, bind_values)
         columns = result.columns.map do |key|
           klass.column_types.fetch(key) {
-            result.column_types.fetch(key) {
-              Class.new { def type_cast(v); v; end }.new
-            }
+            result.column_types.fetch(key) { result.identity_type }
           }
         end
 
-        result = result.map do |attributes|
-          values = klass.initialize_attributes(attributes).values
-
-          columns.zip(values).map do |column, value|
-            column.type_cast(value)
+        result = result.rows.map do |values|
+          values = result.columns.zip(values).map do |column_name, value|
+            single_attr_hash = { column_name => value }
+            klass.initialize_attributes(single_attr_hash).values.first
           end
+
+          columns.zip(values).map { |column, value| column.type_cast value }
         end
         columns.one? ? result.map!(&:first) : result
       end
@@ -192,30 +199,26 @@ module ActiveRecord
     private
 
     def has_include?(column_name)
-      eager_loading? || (includes_values.present? && (column_name || references_eager_loaded_tables?))
+      eager_loading? || (includes_values.present? && ((column_name && column_name != :all) || references_eager_loaded_tables?))
     end
 
     def perform_calculation(operation, column_name, options = {})
+      # TODO: Remove options argument as soon we remove support to
+      # activerecord-deprecated_finders.
       operation = operation.to_s.downcase
 
       # If #count is used with #distinct / #uniq it is considered distinct. (eg. relation.distinct.count)
       distinct = self.distinct_value
-      if options.has_key?(:distinct)
-        ActiveSupport::Deprecation.warn "The :distinct option for `Relation#count` is deprecated. " \
-          "Please use `Relation#distinct` instead. (eg. `relation.distinct.count`)"
-        distinct = options[:distinct]
-      end
 
       if operation == "count"
-        column_name ||= (select_for_count || :all)
+        column_name ||= select_for_count
 
         unless arel.ast.grep(Arel::Nodes::OuterJoin).empty?
           distinct = true
         end
 
         column_name = primary_key if column_name == :all && distinct
-
-        distinct = nil if column_name =~ /\s*DISTINCT\s+/i
+        distinct = nil if column_name =~ /\s*DISTINCT[\s(]+/i
       end
 
       if group_values.any?
@@ -239,7 +242,7 @@ module ActiveRecord
 
     def execute_simple_calculation(operation, column_name, distinct) #:nodoc:
       # Postgresql doesn't like ORDER BY when there are no GROUP BY
-      relation = reorder(nil)
+      relation = unscope(:order)
 
       column_alias = column_name
 
@@ -273,7 +276,7 @@ module ActiveRecord
       group_attrs = group_values
 
       if group_attrs.first.respond_to?(:to_sym)
-        association  = @klass.reflect_on_association(group_attrs.first.to_sym)
+        association  = @klass._reflect_on_association(group_attrs.first.to_sym)
         associated   = group_attrs.size == 1 && association && association.macro == :belongs_to # only count belongs_to associations
         group_fields = Array(associated ? association.foreign_key : group_attrs)
       else
@@ -381,8 +384,9 @@ module ActiveRecord
     # TODO: refactor to allow non-string `select_values` (eg. Arel nodes).
     def select_for_count
       if select_values.present?
-        select = select_values.join(", ")
-        select if select !~ /[,*]/
+        select_values.join(", ")
+      else
+        :all
       end
     end
 

data/lib/active_record/relation/delegation.rb

@@ -1,8 +1,35 @@
-require 'thread'
-require 'thread_safe'
+require 'set'
+require 'active_support/concern'
+require 'active_support/deprecation'
 
 module ActiveRecord
   module Delegation # :nodoc:
+    module DelegateCache
+      def relation_delegate_class(klass) # :nodoc:
+        @relation_delegate_cache[klass]
+      end
+
+      def initialize_relation_delegate_cache # :nodoc:
+        @relation_delegate_cache = cache = {}
+        [
+          ActiveRecord::Relation,
+          ActiveRecord::Associations::CollectionProxy,
+          ActiveRecord::AssociationRelation
+        ].each do |klass|
+          delegate = Class.new(klass) {
+            include ClassSpecificRelation
+          }
+          const_set klass.name.gsub('::', '_'), delegate
+          cache[klass] = delegate
+        end
+      end
+
+      def inherited(child_class)
+        child_class.initialize_relation_delegate_cache
+        super
+      end
+    end
+
     extend ActiveSupport::Concern
 
     # This module creates compiled delegation methods dynamically at runtime, which makes
@@ -10,7 +37,14 @@ module ActiveRecord
     # may vary depending on the klass of a relation, so we create a subclass of Relation
     # for each different klass, and the delegations are compiled into that subclass only.
 
-    delegate :to_xml, :to_yaml, :length, :collect, :map, :each, :all?, :include?, :to_ary, :to => :to_a
+    BLACKLISTED_ARRAY_METHODS = [
+      :compact!, :flatten!, :reject!, :reverse!, :rotate!, :map!,
+      :shuffle!, :slice!, :sort!, :sort_by!, :delete_if,
+      :keep_if, :pop, :shift, :delete_at, :select!
+    ].to_set # :nodoc:
+
+    delegate :to_xml, :to_yaml, :length, :collect, :map, :each, :all?, :include?, :to_ary, :join, to: :to_a
+
     delegate :table_name, :quoted_table_name, :primary_key, :quoted_primary_key,
              :connection, :columns_hash, :to => :klass
 
@@ -38,7 +72,7 @@ module ActiveRecord
               RUBY
             else
               define_method method do |*args, &block|
-                scoping { @klass.send(method, *args, &block) }
+                scoping { @klass.public_send(method, *args, &block) }
               end
             end
           end
@@ -57,13 +91,10 @@ module ActiveRecord
       def method_missing(method, *args, &block)
         if @klass.respond_to?(method)
           self.class.delegate_to_scoped_klass(method)
-          scoping { @klass.send(method, *args, &block) }
-        elsif Array.method_defined?(method)
-          self.class.delegate method, :to => :to_a
-          to_a.send(method, *args, &block)
+          scoping { @klass.public_send(method, *args, &block) }
         elsif arel.respond_to?(method)
           self.class.delegate method, :to => :arel
-          arel.send(method, *args, &block)
+          arel.public_send(method, *args, &block)
         else
           super
         end
@@ -71,52 +102,36 @@ module ActiveRecord
     end
 
     module ClassMethods # :nodoc:
-      @@subclasses = ThreadSafe::Cache.new(:initial_capacity => 2)
-
-      def new(klass, *args)
-        relation = relation_class_for(klass).allocate
-        relation.__send__(:initialize, klass, *args)
-        relation
-      end
-
-      # This doesn't have to be thread-safe. relation_class_for guarantees that this will only be
-      # called exactly once for a given const name.
-      def const_missing(name)
-        const_set(name, Class.new(self) { include ClassSpecificRelation })
+      def create(klass, *args)
+        relation_class_for(klass).new(klass, *args)
       end
 
       private
-      # Cache the constants in @@subclasses because looking them up via const_get
-      # make instantiation significantly slower.
+
       def relation_class_for(klass)
-        if klass && (klass_name = klass.name)
-          my_cache = @@subclasses.compute_if_absent(self) { ThreadSafe::Cache.new }
-          # This hash is keyed by klass.name to avoid memory leaks in development mode
-          my_cache.compute_if_absent(klass_name) do
-            # Cache#compute_if_absent guarantees that the block will only executed once for the given klass_name
-            const_get("#{name.gsub('::', '_')}_#{klass_name.gsub('::', '_')}", false)
-          end
-        else
-          ActiveRecord::Relation
-        end
+        klass.relation_delegate_class(self)
       end
     end
 
     def respond_to?(method, include_private = false)
-      super || Array.method_defined?(method) ||
-        @klass.respond_to?(method, include_private) ||
+      super || @klass.respond_to?(method, include_private) ||
+        array_delegable?(method) ||
         arel.respond_to?(method, include_private)
     end
 
     protected
 
+    def array_delegable?(method)
+      Array.method_defined?(method) && BLACKLISTED_ARRAY_METHODS.exclude?(method)
+    end
+
     def method_missing(method, *args, &block)
       if @klass.respond_to?(method)
-        scoping { @klass.send(method, *args, &block) }
-      elsif Array.method_defined?(method)
-        to_a.send(method, *args, &block)
+        scoping { @klass.public_send(method, *args, &block) }
+      elsif array_delegable?(method)
+        to_a.public_send(method, *args, &block)
       elsif arel.respond_to?(method)
-        arel.send(method, *args, &block)
+        arel.public_send(method, *args, &block)
       else
         super
       end