Changeset 4264

Timestamp:

04/25/06 05:25:04 (4 years ago)

Author:

rick

Message:

Allow all calculations to take the :include option, not just COUNT (closes #4840) [Rick]

Files:

• trunk/activerecord/CHANGELOG (modified) (1 diff)
• trunk/activerecord/lib/active_record/associations.rb (modified) (2 diffs)
• trunk/activerecord/lib/active_record/calculations.rb (modified) (7 diffs)
• trunk/activerecord/test/calculations_test.rb (modified) (2 diffs)

trunk/activerecord/CHANGELOG

@@ -1 +1 @@
-*SVN*
+
+* Allow all calculations to take the :include option, not just COUNT (closes #4840) [Rick]
-
-* Update inconsistent migrations documentation. #4683 [machomagna@gmail.com]

trunk/activerecord/lib/active_record/associations.rb

@@ -967 +967 @@
-        end
-        
-        def count_with_associations(options = {})
-          catch :invalid_query do
-            join_dependency = JoinDependency.new(self, merge_includes(scope(:find, :include), options[:include]), options[:joins])
-            return count_by_sql(construct_counter_sql_with_included_associations(options, join_dependency))
-          end
-          0
-        end
-
-        def find_with_associations(options = {})
-          catch :invalid_query do
@@ -1117 +1109 @@
-            "#{name} Load Including Associations"
-          )
-        end
-        
-        def construct_counter_sql_with_included_associations(options, join_dependency)
-          scope = scope(:find)
-          sql = "SELECT COUNT(DISTINCT #{table_name}.#{primary_key})"
-          
-          # A (slower) workaround if we're using a backend, like sqlite, that doesn't support COUNT DISTINCT.
-          if !Base.connection.supports_count_distinct?
-            sql = "SELECT COUNT(*) FROM (SELECT DISTINCT #{table_name}.#{primary_key}"
-          end
-          
-          sql << " FROM #{table_name} "
-          sql << join_dependency.join_associations.collect{|join| join.association_join }.join
-          
-          add_joins!(sql, options, scope)
-          add_conditions!(sql, options[:conditions], scope)
-          add_limited_ids_condition!(sql, options, join_dependency) if !using_limitable_reflections?(join_dependency.reflections) && ((scope && scope[:limit]) || options[:limit])
-
-          add_limit!(sql, options, scope) if using_limitable_reflections?(join_dependency.reflections)
-
-          if !Base.connection.supports_count_distinct?
-            sql << ")"
-          end
-
-          return sanitize_sql(sql)          
-        end
-

trunk/activerecord/lib/active_record/calculations.rb

@@ -1 +1 @@
-module ActiveRecord
-  module Calculations #:nodoc:
-
+, :include
-    def self.included(base)
-      base.extend(ClassMethods)
@@ -43 +43 @@
-      # Note: Person.count(:all) will not work because it will use :all as the condition.  Use Person.count instead.
-      def count(*args)
-
-
-
-
-
-
-
+
-      end
-
@@ -121 +115 @@
-        column_name     = '*' if column_name == :all
-        column          = column_for column_name
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
-      end
-
@@ -144 +139 @@
-              # Handle legacy paramter options: def count(conditions=nil, joins=nil)
-              options.merge!(:conditions => args[0]) if args.length > 0
-=> args[1])     
+     => args[1])
-            end
-          else
@@ -152 +147 @@
-        end
-      
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-          sql << ", #{options[:group_field]} AS #{options[:group_alias]}" if options[:group]
+          sql << " FROM (SELECT DISTINCT #{column_name}" if use_workaround
-          sql << " FROM #{table_name} "
+          if merged_includes.any?
+            join_dependency = ActiveRecord::Associations::ClassMethods::JoinDependency.new(self, merged_includes, options[:joins])
+            sql << join_dependency.join_associations.collect{|join| join.association_join }.join
+          end
-          add_joins!(sql, options, scope)
-          add_conditions!(sql, options[:conditions], scope)
-          sql << " GROUP BY #{options[:group_field]}" if options[:group]
-
-
-
+
+
+
+
+
-          sql
-        end
-
-aggregate, aggregate_alias, 
-    = connection.select_value(construct_calculation_sql(aggregate, aggregate_alias
+
+= connection.select_value(construct_calculation_sql(operation, column_name
-          type_cast_calculated_value(value, column, operation)
-        end
-
-aggregate, aggregate_alias, 
+
-          group_attr      = options[:group].to_s
-          association     = reflect_on_association(group_attr.to_sym)
@@ -178 +194 @@
-          group_alias     = column_alias_for(group_field)
-          group_column    = column_for group_field
-aggregate, aggregate_alias
+operation, column_name
-          calculated_data = connection.select_all(sql)
+          aggregate_alias = column_alias_for(operation, column_name)
-
-          if association
@@ -196 +213 @@
-      private
-        def validate_calculation_options(operation, options = {})
-
-
-
-
-
-
-
-
-
+
-        end
-

trunk/activerecord/test/calculations_test.rb

@@ -20 +20 @@
-  def test_should_get_maximum_of_field
-    assert_equal 60, Account.maximum(:credit_limit)
+  end
+
+  def test_should_get_maximum_of_field_with_include
+    assert_equal 50, Account.maximum(:credit_limit, :include => :firm, :conditions => "companies.name != 'Summit'")
+  end
+
+  def test_should_get_maximum_of_field_with_scoped_include
+    Account.with_scope :find => { :include => :firm, :conditions => "companies.name != 'Summit'" } do
+      assert_equal 50, Account.maximum(:credit_limit)
+    end
-  end
-
@@ -175 +185 @@
-    end
-    
-    assert_raises(ArgumentError) { Company.send(:validate_calculation_options, :sum,   :include => :posts) }
-    assert_raises(ArgumentError) { Company.send(:validate_calculation_options, :sum,   :foo => :bar) }
-    assert_raises(ArgumentError) { Company.send(:validate_calculation_options, :count, :foo => :bar) }