Ticket #9487: parallel_calculations_and_distinct_records_with_tests.diff

activerecord/lib/active_record/calculations.rb

@@ -1 +1 @@
-module ActiveRecord
-  module Calculations #:nodoc:
-
+distinct_records, :
-    def self.included(base)
-      base.extend(ClassMethods)
-    end
@@ -105 +105 @@
-      # * <tt>:select</tt> - By default, this is * as in SELECT * FROM, but can be changed if you for example want to do a join, but not
-      #   include the joined columns.
-      # * <tt>:distinct</tt> - Set this to true to make this a distinct calculation, such as SELECT COUNT(DISTINCT posts.id) ...
+      # * <tt>:distinct_records</tt>: Set this to true if you want to calculate over distinct records but the values you are summing are not
+      #   necessarily unique. You should use this if you are using <tt>:conditions</tt> based on tables included using <tt>:include</tt> or
+      #   <tt>:joins</tt>. Those LEFT OUTER JOIN statements can lead to duplicates of the base record in the result set, and using
+      #   this option avoids such problems.
-      #
-      # Examples:
-      #   Person.calculate(:count, :all) # The same as Person.count
-      #   Person.average(:age) # SELECT AVG(age) FROM people...
-      #   Person.minimum(:age, :conditions => ['last_name != ?', 'Drake']) # Selects the minimum age for everyone with a last name other than 'Drake'
-      #   Person.minimum(:age, :having => 'min(age) > 17', :group => :last_name) # Selects the minimum age for any family without any minors
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-        validate_calculation_options(operation, options)
-        column_name     = options[:select] if options[:select]
-        column_name     = '*' if column_name == :all
@@ -149 +167 @@
-        end
-
-        def construct_calculation_sql(operation, column_name, options) #:nodoc:
-
+ unless operation.is_a?(Hash)
-          options = options.symbolize_keys
-
-          scope           = scope(:find)
@@ -167 +185 @@
-            end
-          end
-
-
+
+
+
+
+
+
+
+
+
+
-
-          # A (slower) workaround if we're using a backend, like sqlite, that doesn't support COUNT DISTINCT.
-          sql = "SELECT COUNT(*) AS #{aggregate_alias}" if use_workaround
-
-          sql << ", #{options[:group_field]} AS #{options[:group_alias]}" if options[:group]
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-          sql << " FROM #{connection.quote_table_name(table_name)} "
-          if merged_includes.any?
-            join_dependency = ActiveRecord::Associations::ClassMethods::JoinDependency.new(self, merged_includes, options[:joins])
@@ -200 +241 @@
-
-          sql << " ORDER BY #{options[:order]} "       if options[:order]
-          add_limit!(sql, options, scope)
-
+
+
-          sql
-        end
-
+        def extract_query_information_from_operation(operation)
+          return nil unless operation.is_a?(Hash)
+          calculations = []
+          operation.each do |key, value|
+            value = value.to_s.to_a unless value.is_a?(Array)
+            calculations << {:alias => key.to_s, :distinct_alias => "#{key}_#{value[0]}_alias",
+                :operation => value[0].to_s.downcase, :column => value[1].to_s}
+          end
+          calculations
+        end
+
-        def execute_simple_calculation(operation, column_name, column, options) #:nodoc:
-
-
+
+
+
+
+
+
+
+
+
+
+
+
-        end
-
-        def execute_grouped_calculation(operation, column_name, column, options) #:nodoc:

activerecord/test/cases/calculations_test.rb

@@ -15 +15 @@
-    assert_equal 318, Account.sum(:credit_limit)
-  end
-
+  def test_should_sum_field_without_repeated_records
+    assert_equal 7, Author.sum("#{Author.table_name}.id", :include => :posts)
+    assert_equal 3, Author.sum("#{Author.table_name}.id", :include => :posts, :distinct_records => true)
+    assert_equal 12, Post.sum(:author_id, :include => :comments)
+    assert_equal 7, Post.sum(:author_id, :include => :comments, :distinct_records => true)
+  end
+
-  def test_should_average_field
-    value = Account.average(:credit_limit)
-    assert_kind_of Float, value
@@ -215 +222 @@
-        # empty options are valid
-        Company.send(:validate_calculation_options, func)
-        # these options are valid for all calculations
-].each do |opt|
+, :distinct_records].each do |opt| 
-          Company.send(:validate_calculation_options, func, opt => true)
-        end
-      end
@@ -248 +255 @@
-  def test_count_with_too_many_parameters_raises
-    assert_raise(ArgumentError) { Account.count(1, 2, 3) }
-  end
+
+  def test_parallel_calculations
+    account_calculations = Account.calculate(:how_many => :count, :total_credit => [:sum, :credit_limit], :max_limit => [:max, :credit_limit])
+    assert_equal 6, account_calculations[:how_many]
+    assert_equal 318, account_calculations[:total_credit]
+    assert_equal 60, account_calculations[:max_limit]
+  end
+
+  def test_parallel_calculations_with_conditions
+    account_calculations = Account.calculate({:how_many => [:count, '*'], :total_credit => [:sum, :credit_limit]}, :conditions => {:credit_limit => 50})
+    assert_equal 3, account_calculations[:how_many]
+    assert_equal 150, account_calculations[:total_credit]
+  end
+
+  def test_parallel_calculations_with_conditions_and_distinct
+    account_calculations = Account.calculate(
+        {:how_many => [:count, :credit_limit], :total_credit => [:sum, :credit_limit]},
+        :conditions => {:credit_limit => 50},
+        :distinct => true
+    )
+    assert_equal 1, account_calculations[:how_many]
+    assert_equal 50, account_calculations[:total_credit]
+  end
+
+  def test_parallel_calculation_with_distinct_records
+    author_calculations = Author.calculate({:total_id => [:sum, "#{Author.table_name}.id"]}, :include => :posts)
+    distinct_author_calculations = Author.calculate({:total_id => [:sum, "#{Author.table_name}.id"]}, :include => :posts, :distinct_records => true)
+    assert_equal 7, author_calculations[:total_id]
+    assert_equal 3, distinct_author_calculations[:total_id]
+  end
-end