Permalink
Browse files

Delegate count to Relation

  • Loading branch information...
1 parent 88ffba2 commit 73b179eb689611ac0518584b21f2304756a7e981 @lifo lifo committed Jan 19, 2010
View
63 activerecord/lib/active_record/calculations.rb
@@ -3,68 +3,7 @@ module Calculations #:nodoc:
extend ActiveSupport::Concern
module ClassMethods
- # Count operates using three different approaches.
- #
- # * Count all: By not passing any parameters to count, it will return a count of all the rows for the model.
- # * Count using column: By passing a column name to count, it will return a count of all the rows for the model with supplied column present
- # * Count using options will find the row count matched by the options used.
- #
- # The third approach, count using options, accepts an option hash as the only parameter. The options are:
- #
- # * <tt>:conditions</tt>: An SQL fragment like "administrator = 1" or [ "user_name = ?", username ]. See conditions in the intro to ActiveRecord::Base.
- # * <tt>:joins</tt>: Either an SQL fragment for additional joins like "LEFT JOIN comments ON comments.post_id = id" (rarely needed)
- # or named associations in the same form used for the <tt>:include</tt> option, which will perform an INNER JOIN on the associated table(s).
- # If the value is a string, then the records will be returned read-only since they will have attributes that do not correspond to the table's columns.
- # Pass <tt>:readonly => false</tt> to override.
- # * <tt>:include</tt>: Named associations that should be loaded alongside using LEFT OUTER JOINs. The symbols named refer
- # to already defined associations. When using named associations, count returns the number of DISTINCT items for the model you're counting.
- # See eager loading under Associations.
- # * <tt>:order</tt>: An SQL fragment like "created_at DESC, name" (really only used with GROUP BY calculations).
- # * <tt>:group</tt>: An attribute name by which the result should be grouped. Uses the GROUP BY SQL-clause.
- # * <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>:from</tt> - By default, this is the table name of the class, but can be changed to an alternate table name (or even the name
- # of a database view).
- #
- # Examples for counting all:
- # Person.count # returns the total count of all people
- #
- # Examples for counting by column:
- # Person.count(:age) # returns the total count of all people whose age is present in database
- #
- # Examples for count with options:
- # Person.count(:conditions => "age > 26")
- # Person.count(:conditions => "age > 26 AND job.salary > 60000", :include => :job) # because of the named association, it finds the DISTINCT count using LEFT OUTER JOIN.
- # Person.count(:conditions => "age > 26 AND job.salary > 60000", :joins => "LEFT JOIN jobs on jobs.person_id = person.id") # finds the number of rows matching the conditions and joins.
- # Person.count('id', :conditions => "age > 26") # Performs a COUNT(id)
- # Person.count(:all, :conditions => "age > 26") # Performs a COUNT(*) (:all is an alias for '*')
- #
- # Note: <tt>Person.count(:all)</tt> will not work because it will use <tt>:all</tt> as the condition. Use Person.count instead.
- def count(*args)
- case args.size
- when 0
- construct_calculation_arel.count
- when 1
- if args[0].is_a?(Hash)
- options = args[0]
- distinct = options.has_key?(:distinct) ? options.delete(:distinct) : false
- construct_calculation_arel(options).count(options[:select], :distinct => distinct)
- else
- construct_calculation_arel.count(args[0])
- end
- when 2
- column_name, options = args
- distinct = options.has_key?(:distinct) ? options.delete(:distinct) : false
- construct_calculation_arel(options).count(column_name, :distinct => distinct)
- else
- raise ArgumentError, "Unexpected parameters passed to count(): #{args.inspect}"
- end
- rescue ThrowResult
- 0
- end
-
- delegate :average, :minimum, :maximum, :sum, :to => :scoped
+ delegate :count, :average, :minimum, :maximum, :sum, :to => :scoped
# This calculates aggregate values in the given column. Methods for count, sum, average, minimum, and maximum have been added as shortcuts.
# Options such as <tt>:conditions</tt>, <tt>:order</tt>, <tt>:group</tt>, <tt>:having</tt>, and <tt>:joins</tt> can be passed to customize the query.
View
65 activerecord/lib/active_record/relation/calculation_methods.rb
@@ -1,8 +1,55 @@
module ActiveRecord
module CalculationMethods
-
- def count(*args)
- calculate(:count, *construct_count_options_from_args(*args))
+ # Count operates using three different approaches.
+ #
+ # * Count all: By not passing any parameters to count, it will return a count of all the rows for the model.
+ # * Count using column: By passing a column name to count, it will return a count of all the rows for the model with supplied column present
+ # * Count using options will find the row count matched by the options used.
+ #
+ # The third approach, count using options, accepts an option hash as the only parameter. The options are:
+ #
+ # * <tt>:conditions</tt>: An SQL fragment like "administrator = 1" or [ "user_name = ?", username ]. See conditions in the intro to ActiveRecord::Base.
+ # * <tt>:joins</tt>: Either an SQL fragment for additional joins like "LEFT JOIN comments ON comments.post_id = id" (rarely needed)
+ # or named associations in the same form used for the <tt>:include</tt> option, which will perform an INNER JOIN on the associated table(s).
+ # If the value is a string, then the records will be returned read-only since they will have attributes that do not correspond to the table's columns.
+ # Pass <tt>:readonly => false</tt> to override.
+ # * <tt>:include</tt>: Named associations that should be loaded alongside using LEFT OUTER JOINs. The symbols named refer
+ # to already defined associations. When using named associations, count returns the number of DISTINCT items for the model you're counting.
+ # See eager loading under Associations.
+ # * <tt>:order</tt>: An SQL fragment like "created_at DESC, name" (really only used with GROUP BY calculations).
+ # * <tt>:group</tt>: An attribute name by which the result should be grouped. Uses the GROUP BY SQL-clause.
+ # * <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>:from</tt> - By default, this is the table name of the class, but can be changed to an alternate table name (or even the name
+ # of a database view).
+ #
+ # Examples for counting all:
+ # Person.count # returns the total count of all people
+ #
+ # Examples for counting by column:
+ # Person.count(:age) # returns the total count of all people whose age is present in database
+ #
+ # Examples for count with options:
+ # Person.count(:conditions => "age > 26")
+ # Person.count(:conditions => "age > 26 AND job.salary > 60000", :include => :job) # because of the named association, it finds the DISTINCT count using LEFT OUTER JOIN.
+ # Person.count(:conditions => "age > 26 AND job.salary > 60000", :joins => "LEFT JOIN jobs on jobs.person_id = person.id") # finds the number of rows matching the conditions and joins.
+ # Person.count('id', :conditions => "age > 26") # Performs a COUNT(id)
+ # Person.count(:all, :conditions => "age > 26") # Performs a COUNT(*) (:all is an alias for '*')
+ #
+ # Note: <tt>Person.count(:all)</tt> will not work because it will use <tt>:all</tt> as the condition. Use Person.count instead.
+ def count(column_name = nil, options = {})
+ column_name, options = nil, column_name if column_name.is_a?(Hash)
+ column_name = select_for_count unless column_name
+ distinct = options.delete(:distinct)
+
+ if options.any?
+ calculation_relation(options).count(column_name, :distinct => distinct)
+ else
+ relation_for_association_calculations.calculate(:count, column_name || :all, :distinct => distinct)
+ end
+ rescue ThrowResult
+ 0
end
# Calculates the average value on a given column. The value is returned as
@@ -73,12 +120,16 @@ def calculation_relation(options = {})
if options.present?
apply_finder_options(options.except(:distinct)).calculation_relation
else
- (eager_loading? || includes_values.present?) ? construct_relation_for_association_calculations : self
+ relation_for_association_calculations
end
end
private
+ def relation_for_association_calculations
+ (eager_loading? || includes_values.present?) ? construct_relation_for_association_calculations : self
+ end
+
def execute_simple_calculation(operation, column_name, distinct) #:nodoc:
column = if @klass.column_names.include?(column_name.to_s)
Arel::Attribute.new(@klass.unscoped, column_name)
@@ -196,5 +247,11 @@ def get_projection_name_from_chained_relations
@select_values.join(", ") if @select_values.present?
end
+ def select_for_count
+ if @select_values.present?
+ select = @select_values.join(", ")
+ select if select !~ /(,|\*)/
+ end
+ end
end
end
View
7 activerecord/lib/active_record/relation/finder_methods.rb
@@ -56,12 +56,17 @@ def find_with_associations
def construct_relation_for_association_calculations
including = (@eager_load_values + @includes_values).uniq
join_dependency = ActiveRecord::Associations::ClassMethods::JoinDependency.new(@klass, including, arel.joins(arel))
- construct_relation_for_association_find(join_dependency)
+
+ relation = except(:includes, :eager_load, :preload)
+ apply_join_dependency(relation, join_dependency)
end
def construct_relation_for_association_find(join_dependency)
relation = except(:includes, :eager_load, :preload, :select).select(@klass.send(:column_aliases, join_dependency))
+ apply_join_dependency(relation, join_dependency)
+ end
+ def apply_join_dependency(relation, join_dependency)
for association in join_dependency.join_associations
relation = association.join_relation(relation)
end

0 comments on commit 73b179e

Please sign in to comment.