aggregate_columns 0.9.4 → 0.9.5

data/.hgignore

@@ -1,3 +1,4 @@
 syntax: glob
 *swp
 pkg/*
+*.gem

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in aggregate_columns.gemspec
+gemspec

data/README

@@ -11,7 +11,6 @@ Take a classic example:
 
 class Post
 	has_many :comments
-	has_many :tags
 end
 
 Now let's say you want to display a table with some posts' attributes including
@@ -20,25 +19,109 @@ generates separate query for each post. Alternatively you could use counter
 cache, but it can get out of sync plus it only works on this simple example,
 while you could also need the time of latest comment for each post.
 
+Rails 3
+=======
 
 AggregateColumns solution would look like this:
 
-	Post.all( Post.aggregate_columns_options( :association => :comments ))
+	posts = Post.aggregate_columns( :association => :comments )
+
+	SELECT posts.*, (SELECT count(*) AS comment_count FROM comments 
+	WHERE (posts.id = post_id)) AS comment_count FROM "posts" 
+	ORDER BY comment_count DESC
+
+	posts.first.comment_count # => "1"
+
+This returns a full blown ActiveRecord::Relation object encapsulating a query
+for posts with additional column called "comment_count" containing (big surprise
+here) number of comments for each post. I'm taking advantage of the fact columns
+specified in :select option are kept inside model objects (but not
+type-casted, so comment_count would be a String).
 
-This returns posts with additional column called "comment_count" containing (big
-surprise here) number of comments for each post. I'm taking advantage of the
-fact columns specified in :select option are reachable from fetched objects (but
-not type-casted, so comment_count will be a String).
+Options:
+ * :association - association to aggregate
+ * :function - SQL aggregate function to use, defaults to count
+ * :column - associated table column to aggregate, defaults to '*' (useful for
+   count)
+ * :result_column - name of resulting column, defaults to
+   association_field_function with exception of '*' column, which results in 
+	 association.singularize_function
+ * :join_type - JOIN type for in-join mode, explained later
 
+Ordering defaults to aggregate column descending, you may always change it using
+reorder. The reason for using this default is that in my experience this is the
+only order I needed :)
 
 What if you did not want such a simple aggregation, but the one I already
 mentioned: time of latest comment for each post:
 
-	Post.all( Post.aggregate_columns_options( :association => :comments, :function => :max, :column => :created_at ))
+	Post.aggregate_columns( :association => :comments, :function => :max, :column => :created_at )
+
+	SELECT posts.*, (SELECT max(created_at) AS comments_created_at_max FROM
+	comments WHERE (posts.id = post_id)) AS comments_created_at_max FROM "posts"
+	ORDER BY comments_created_at_max DESC
 
 The name of aggregated column would be comments_created_at_max in this case, but
 it can be changed using :result_column option.
 
+You may add some additional relations to the subquery using a block, eg.
+
+	Post.aggregate_columns( :association => :comments ) { |rel| rel.where( :user_id => 1 ) }
+
+	SELECT posts.*, (SELECT count(*) AS comment_count FROM comments WHERE
+	"comments"."user_id" = 1 AND (posts.id = post_id)) AS comment_count FROM
+	"posts" ORDER BY comment_count DESC
+
+This may you can limit which comments are considered for aggregation.
+
+The only option not mentioned yet is :join_type, which can only be explained
+after digging deeper into how the gem works. Aggregate column is added in one of
+two ways:
+
+* if :join_type option is not present - it's appended as subquery to SELECT
+  clause, eg:
+
+	SELECT posts.*, (SELECT count(*) AS comment_count FROM comments WHERE
+	(posts.id = post_id)) AS comment_count FROM "posts" ORDER BY comment_count
+	DESC
+
+* if :join_type option is present - it's added as a subquery connected using
+  JOIN clause with join type specified, eg (:join_type => :right):
+
+	SELECT posts.*, comment_count FROM "posts" RIGHT JOIN (SELECT post_id,
+	count(*) AS comment_count FROM comments GROUP BY post_id) comment_count_join
+	ON posts.id = comment_count_join.post_id ORDER BY comment_count DESC
+	
+Now, each way has it's place.
+
+In-select subquery:
+* foreign key index is used (PostgreSQL at least)
+* subquery executed only for rows fetched from main table
+
+In-join subquery:
+* with RIGHT join only fetches records from main table having results in
+  aggregate column (eg. only posts with any comments)
+
+You can only decide between those two on a case by case basis. But generally: if
+you only care about records having some meaningful values in aggregate column,
+in-join might be better; if main table has some large record count, but you only
+want to select some subset of those, in-select might save you some computation
+time.
+
+Rails 2
+=======
+
+NOTE: this is deprecated and I'm not sure if it even still works. But the code
+is there, so it might be useful for someone.
+
+
+Instead of aggregate_columns you have aggregate_column_options:
+
+	Post.aggregate_columns_options( :association => :comments )
+
+which returns a Hash of options suitable to pass to .find call. You have
+additional options: :joins and :conditions to be passed to the subquery, because
+you don't have a Relation object to work on in a block.
 
 Now something really complicated - sum of votes for comments whose authors are
 active. Here's where :conditions and :joins options come in handy:
@@ -53,6 +136,9 @@ active. Here's where :conditions and :joins options come in handy:
 		)
 	)
 
+:joins and :conditions are passed to the subquery, so they will determine which
+comments are considered when calculating vote sum
+
 Important things to note here:
 * aggregate_column_options return :select, :joins and :order options, so those
 	cannot be used for other purposes
@@ -60,7 +146,6 @@ Important things to note here:
 	with normal find options (other than aforementioned ones). This means you can
 	merge resulting options with eg. custom :conditions
 
-
 You may also define multiple aggregate columns in one call:
 
 	Post.aggregate_columns_options( 
@@ -68,20 +153,10 @@ You may also define multiple aggregate columns in one call:
 		{ :association => :tags, :result_column => :number_of_tags }
 	)
 
-
 Yet another method to combine aggregate columns with other find options is to use scopes:
 
 	Post.aggregate_columns_scope( :association => :comments ).scoped( ...
 
-Rails 3
-=======
-
-In Rails 3 you should use:
-	
-	Post.aggregate_colums( :association => :comments )
-
-which returns a full blown ActiveRecord::Relation object
-
 Thanks
 ======
 

data/Rakefile

@@ -1 +1,9 @@
 require "bundler/gem_tasks"
+
+# Now I have no idea why this doesn't work without specifying the task explicitly
+require "rake/testtask"
+Rake::TestTask.new do |t|
+  t.libs << "test"
+  t.test_files = FileList['test/*test.rb']
+  t.verbose = true
+end

data/aggregate_columns.gemspec

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "aggregate_columns/version"
+
+Gem::Specification.new do |s|
+  s.name        = "aggregate_columns"
+  s.version     = AggregateColumns::VERSION
+  s.authors     = ["Marek Janukowicz/Starware"]
+  s.email       = ["marek@janukowicz.net"]
+  s.homepage    = ""
+  s.summary 		= "Create and use aggregate columns in Rails applications"
+  s.description = ""
+
+  s.files         = `hg manifest`.split("\n")
+  s.test_files    = `hg manifest | grep ^test`.split("\n")
+  s.executables   = `hg manifest | grep ^bin`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  # specify any dependencies here; for example:
+  # s.add_development_dependency "rspec"
+  s.add_runtime_dependency "activerecord", ">= 2"
+	s.add_development_dependency "rake"
+  s.add_development_dependency "activerecord", ">= 2"
+	s.add_development_dependency "activesupport", ">= 2"
+	s.add_development_dependency "activerecord-nulldb-adapter"
+
+end

data/lib/aggregate_columns.rb

@@ -93,10 +93,10 @@ module AggregateColumns
 
 end
 
-# All versions
-ActiveRecord::Base.send( :extend, AggregateColumns::MethodsRails2 )
-if defined?( ActiveRecord::Relation )
+if defined?( ActiveRecord::Relation ) # Rails 3
   ActiveRecord::Base.send( :extend, AggregateColumns::MethodsRails3 )
+else # Rails 2
+  ActiveRecord::Base.send( :extend, AggregateColumns::MethodsRails2 )
 end
 
 ## Rails 2

data/lib/aggregate_columns/version.rb

@@ -0,0 +1,3 @@
+module AggregateColumns
+  VERSION = "0.9.5"
+end

data/test/rails_2_test.rb

@@ -0,0 +1,86 @@
+# TODO: this test doesn't really work with Rails 2
+require 'active_record'
+require 'rails'
+
+if Rails::VERSION::MAJOR == 2
+
+  require 'test_helper'
+
+  class Rails2Test < ActiveSupport::TestCase
+
+    class Post < FakeModel
+    end
+
+    class User < FakeModel
+      has_many :posts
+    end
+
+    def setup
+      @user = User.new
+    end
+
+    test "empty options" do
+      options = User.aggregate_columns_options
+      assert_equal "users.*", options[:select]
+      assert options[:order].blank?
+      assert options[:joins].blank?
+    end
+
+    test "empty hash as options should fail" do
+      assert_raise( ArgumentError ) do
+        options = User.aggregate_columns_options( {} )
+      end
+    end
+
+    test "only association" do
+      options = User.aggregate_columns_options( :association => :posts )
+      assert_equal "users.*, post_count", options[:select]
+      assert_equal "post_count DESC", options[:order]
+      assert_equal "LEFT JOIN (SELECT user_id, count(*) AS post_count FROM posts  GROUP BY user_id) post_count_join ON posts.id = post_count_join.user_id", options[:joins]
+    end
+
+    test "column function" do
+      options = User.aggregate_columns_options( :association => :posts, :column => :created_at, :function => :max )
+      assert_equal "users.*, posts_created_at_max", options[:select]
+      assert_equal "posts_created_at_max DESC", options[:order]
+      assert_equal "LEFT JOIN (SELECT user_id, max(created_at) AS posts_created_at_max FROM posts  GROUP BY user_id) posts_created_at_max_join ON posts.id = posts_created_at_max_join.user_id", options[:joins]
+    end
+
+    test "result_column" do
+      options = User.aggregate_columns_options( :association => :posts, :column => :created_at, :function => :max, :result_column => "last_post_time" )
+      assert_equal "users.*, last_post_time", options[:select]
+      assert_equal "last_post_time DESC", options[:order]
+      assert_equal "LEFT JOIN (SELECT user_id, max(created_at) AS last_post_time FROM posts  GROUP BY user_id) last_post_time_join ON posts.id = last_post_time_join.user_id", options[:joins]
+    end
+
+    test "join_type" do
+      options = User.aggregate_columns_options( :association => :posts, :column => :created_at, :function => :max, :join_type => "RIGHT" )
+      assert_equal "users.*, posts_created_at_max", options[:select]
+      assert_equal "posts_created_at_max DESC", options[:order]
+      assert_equal "RIGHT JOIN (SELECT user_id, max(created_at) AS posts_created_at_max FROM posts  GROUP BY user_id) posts_created_at_max_join ON posts.id = posts_created_at_max_join.user_id", options[:joins]
+    end
+
+    test "conditions" do
+      options = User.aggregate_columns_options( :association => :posts, :column => :created_at, :function => :max, :conditions => { :active => true } )
+      assert_equal "users.*, posts_created_at_max", options[:select]
+      assert_equal "posts_created_at_max DESC", options[:order]
+      assert_equal "LEFT JOIN (SELECT user_id, max(created_at) AS posts_created_at_max FROM posts  WHERE posts.active = true GROUP BY user_id) posts_created_at_max_join ON posts.id = posts_created_at_max_join.user_id", options[:joins]
+    end
+
+    test "joins" do
+      time = 2.days.ago
+      options = User.aggregate_columns_options( :association => :posts, :column => :created_at, :function => :max, :joins => "INNER JOIN comments ON comments.post_id = posts.id", :conditions => ["comments.updated_at > ?", time] )
+      assert_equal "users.*, posts_created_at_max", options[:select]
+      assert_equal "posts_created_at_max DESC", options[:order]
+      assert_equal "LEFT JOIN (SELECT user_id, max(created_at) AS posts_created_at_max FROM posts INNER JOIN comments ON comments.post_id = posts.id WHERE comments.updated_at > #{time} GROUP BY user_id) posts_created_at_max_join ON posts.id = posts_created_at_max_join.user_id", options[:joins]
+    end
+
+    test "order" do
+      options = User.aggregate_columns_options( :association => :posts, :order => :asc )
+      assert_equal "users.*, post_count", options[:select]
+      assert_equal "post_count ASC", options[:order]
+      assert_equal "LEFT JOIN (SELECT user_id, count(*) AS post_count FROM posts  GROUP BY user_id) post_count_join ON posts.id = post_count_join.user_id", options[:joins]
+    end
+
+  end
+end

data/test/rails_3_test.rb

@@ -0,0 +1,80 @@
+require 'active_record'
+require 'rails'
+
+if Rails::VERSION::MAJOR == 3
+  require 'test/unit'
+  require 'aggregate_columns'
+
+  # Workaround for nulldb Rails 3.1 incompatibility
+  class Object
+    alias_method :returning, :tap
+  end
+
+  class Rails3Test < Test::Unit::TestCase
+
+    ActiveRecord::Base.establish_connection :adapter => :nulldb
+
+    class Post < ActiveRecord::Base
+      has_many :comments
+    end
+
+    class Comment < ActiveRecord::Base
+      belongs_to :post
+    end
+
+    def test_only_association
+      relation = Post.aggregate_columns( :association => :comments )
+      assert_equal 2, relation.select_values.count
+      assert relation.select_values.include?( "(SELECT count(*) AS comment_count FROM comments  WHERE (posts.id = post_id)) AS comment_count" )
+      assert_equal relation.order_values, ["comment_count DESC"]
+      assert_empty relation.where_values
+      assert_empty relation.joins_values
+    end
+
+    # Reorder doesn't work, probably I don't understand how it is supposed to work
+    #def test_reorder
+    #  relation = Post.aggregate_columns( :association => :comments ).reorder( "posts.id ASC" )
+    #end
+
+    def test_function_and_column
+      relation = Post.aggregate_columns( :association => :comments, :function => :max, :column => :created_at )
+      assert_equal 2, relation.select_values.count
+      assert relation.select_values.include?( "(SELECT max(created_at) AS comments_created_at_max FROM comments  WHERE (posts.id = post_id)) AS comments_created_at_max" )
+      assert_equal relation.order_values, ["comments_created_at_max DESC"]
+      assert_empty relation.where_values
+      assert_empty relation.joins_values
+    end
+
+    def test_result_column
+      relation = Post.aggregate_columns( :association => :comments, :function => :max, :column => :created_at, :result_column => :max_created_at )
+      assert_equal 2, relation.select_values.count
+      assert relation.select_values.include?( "(SELECT max(created_at) AS max_created_at FROM comments  WHERE (posts.id = post_id)) AS max_created_at" )
+      assert_equal relation.order_values, ["max_created_at DESC"]
+      assert_empty relation.where_values
+      assert_empty relation.joins_values
+    end
+
+    def test_right_join
+      relation = Post.aggregate_columns( :association => :comments, :join_type => :right )
+      assert_equal 2, relation.select_values.count
+      assert relation.select_values.include?( "comment_count" )
+      assert_equal relation.joins_values, ["RIGHT JOIN (SELECT post_id, count(*) AS comment_count FROM comments  GROUP BY post_id) comment_count_join ON posts.id = comment_count_join.post_id"]
+      assert_equal ["comment_count DESC"], relation.order_values
+      assert_empty relation.where_values
+    end
+
+    def test_where_clauses
+      relation = Post.where( :id => 2 ).aggregate_columns( :association => :comments ) { |rel| rel.where( :id => 1 ) }
+      assert_equal "posts.id = 2", relation.where_values.first.to_sql # Additional "where" means where_values must be processed with to_sql instead of querying directly
+      assert relation.select_values.include?( "(SELECT count(*) AS comment_count FROM comments  WHERE comments.id = 1 AND (posts.id = post_id)) AS comment_count" )
+    end
+
+    def test_multiple_aggregates
+      relation = Post.aggregate_columns( :association => :comments, :join_type => :right ).aggregate_columns( :association => :comments ).aggregate_columns( :association => :comments, :function => :sum, :column => :vote, :result_column => :number_of_votes )
+      assert_empty relation.where_values
+      assert relation.select_values.include?( "comment_count" )
+      assert relation.joins_values.include?( "RIGHT JOIN (SELECT post_id, count(*) AS comment_count FROM comments  GROUP BY post_id) comment_count_join ON posts.id = comment_count_join.post_id" )
+    end
+
+  end
+end

data/test/test_helper.rb

@@ -1,6 +1,8 @@
+# Rails 2 helper - doesn't really work, as do Rails 2 tests themselves
+
 require 'rubygems'
 require 'test/unit'
-gem 'activesupport'#, "< 3.0.0"
+#gem 'activesupport'
 require 'active_support/test_case'
 require 'active_record'
 require 'active_record/base'

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: aggregate_columns
 version: !ruby/object:Gem::Version 
-  hash: 51
+  hash: 49
   prerelease: 
   segments: 
   - 0
   - 9
-  - 4
-  version: 0.9.4
+  - 5
+  version: 0.9.5
 platform: ruby
 authors: 
 - Marek Janukowicz/Starware
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-12-09 00:00:00 +01:00
+date: 2012-01-03 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -32,6 +32,62 @@ dependencies:
         version: "2"
   type: :runtime
   version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rake
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: activerecord
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 2
+        version: "2"
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 2
+        version: "2"
+  type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: activerecord-nulldb-adapter
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id005
 description: ""
 email: 
 - marek@janukowicz.net
@@ -43,10 +99,14 @@ extra_rdoc_files: []
 
 files: 
 - .hgignore
+- Gemfile
 - README
 - Rakefile
+- aggregate_columns.gemspec
 - lib/aggregate_columns.rb
-- test/aggregate_columns_test.rb
+- lib/aggregate_columns/version.rb
+- test/rails_2_test.rb
+- test/rails_3_test.rb
 - test/test_helper.rb
 has_rdoc: true
 homepage: ""
@@ -83,5 +143,6 @@ signing_key:
 specification_version: 3
 summary: Create and use aggregate columns in Rails applications
 test_files: 
-- test/aggregate_columns_test.rb
+- test/rails_2_test.rb
+- test/rails_3_test.rb
 - test/test_helper.rb

data/test/aggregate_columns_test.rb

@@ -1,82 +0,0 @@
-require 'test_helper'
-
-class AggregateColumnsTest < ActiveSupport::TestCase
-
-  class Post < FakeModel
-  end
-
-  class User < FakeModel
-    has_many :posts
-  end
-
-  def setup
-    @user = User.new
-  end
-
-  #test "empty options" do
-  #  options = User.aggregate_columns_options
-  #  assert_equal "users.*", options[:select]
-  #  assert options[:order].blank?
-  #  assert options[:joins].blank?
-  #end
-
-  #test "empty hash as options should fail" do
-  #  assert_raise( ArgumentError ) do
-  #    options = User.aggregate_columns_options( {} )
-  #  end
-  #end
-
-  #test "only association" do
-  #  options = User.aggregate_columns_options( :association => :posts )
-  #  assert_equal "users.*, post_count", options[:select]
-  #  assert_equal "post_count DESC", options[:order]
-  #  assert_equal "LEFT JOIN (SELECT user_id, count(*) AS post_count FROM posts  GROUP BY user_id) post_count_join ON posts.id = post_count_join.user_id", options[:joins]
-  #end
-
-  #test "column function" do
-  #  options = User.aggregate_columns_options( :association => :posts, :column => :created_at, :function => :max )
-  #  assert_equal "users.*, posts_created_at_max", options[:select]
-  #  assert_equal "posts_created_at_max DESC", options[:order]
-  #  assert_equal "LEFT JOIN (SELECT user_id, max(created_at) AS posts_created_at_max FROM posts  GROUP BY user_id) posts_created_at_max_join ON posts.id = posts_created_at_max_join.user_id", options[:joins]
-  #end
-
-  #test "result_column" do
-  #  options = User.aggregate_columns_options( :association => :posts, :column => :created_at, :function => :max, :result_column => "last_post_time" )
-  #  assert_equal "users.*, last_post_time", options[:select]
-  #  assert_equal "last_post_time DESC", options[:order]
-  #  assert_equal "LEFT JOIN (SELECT user_id, max(created_at) AS last_post_time FROM posts  GROUP BY user_id) last_post_time_join ON posts.id = last_post_time_join.user_id", options[:joins]
-  #end
-
-  #test "join_type" do
-  #  options = User.aggregate_columns_options( :association => :posts, :column => :created_at, :function => :max, :join_type => "RIGHT" )
-  #  assert_equal "users.*, posts_created_at_max", options[:select]
-  #  assert_equal "posts_created_at_max DESC", options[:order]
-  #  assert_equal "RIGHT JOIN (SELECT user_id, max(created_at) AS posts_created_at_max FROM posts  GROUP BY user_id) posts_created_at_max_join ON posts.id = posts_created_at_max_join.user_id", options[:joins]
-  #end
-
-  #test "conditions" do
-  #  options = User.aggregate_columns_options( :association => :posts, :column => :created_at, :function => :max, :conditions => { :active => true } )
-  #  assert_equal "users.*, posts_created_at_max", options[:select]
-  #  assert_equal "posts_created_at_max DESC", options[:order]
-  #  assert_equal "LEFT JOIN (SELECT user_id, max(created_at) AS posts_created_at_max FROM posts  WHERE posts.active = true GROUP BY user_id) posts_created_at_max_join ON posts.id = posts_created_at_max_join.user_id", options[:joins]
-  #end
-
-  #test "joins" do
-  #  time = 2.days.ago
-  #  options = User.aggregate_columns_options( :association => :posts, :column => :created_at, :function => :max, :joins => "INNER JOIN comments ON comments.post_id = posts.id", :conditions => ["comments.updated_at > ?", time] )
-  #  assert_equal "users.*, posts_created_at_max", options[:select]
-  #  assert_equal "posts_created_at_max DESC", options[:order]
-  #  assert_equal "LEFT JOIN (SELECT user_id, max(created_at) AS posts_created_at_max FROM posts INNER JOIN comments ON comments.post_id = posts.id WHERE comments.updated_at > #{time} GROUP BY user_id) posts_created_at_max_join ON posts.id = posts_created_at_max_join.user_id", options[:joins]
-  #end
-
-  #test "order" do
-  #  options = User.aggregate_columns_options( :association => :posts, :order => :asc )
-  #  assert_equal "users.*, post_count", options[:select]
-  #  assert_equal "post_count ASC", options[:order]
-  #  assert_equal "LEFT JOIN (SELECT user_id, count(*) AS post_count FROM posts  GROUP BY user_id) post_count_join ON posts.id = post_count_join.user_id", options[:joins]
-  #end
-
-  # TODO:
-  # test multiple aggregates
-  # test with real database
-end