activerecord-precount 0.4.3 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 03bcfbd6e4eeb0e73abd3ba62ce3479ce88be195
-  data.tar.gz: ed4a627ba81085af77fc6c0fc0c5036d6aed498b
+  metadata.gz: b808e109c4ff4e66a60696bef99eb38a78f2c729
+  data.tar.gz: abed0c7c35ef630938eec845e4439a7e62f54e90
 SHA512:
-  metadata.gz: 9ec150f0c07963351a74c8657673bb14a3afe9e4476c19658ea74a1e489b89e21f5abc876aa097c703460db396069cacf54bfd7a70ab0e536c9a20c953d5a46f
-  data.tar.gz: 0c50e140ed0cfb414f64c380e3fd95c92083a207e2b2dbf144536d285d24bc1c23ded87944eeb74ecce362aa493c818b5fc0097621e9ea32902b7eb73f8433bf
+  metadata.gz: 36e5f8ad70b97aa1d58990791ec8a7de3e075783700d25e8ffc93be693c2d9f39b29da237b46d5159e750654ea3b50b80c99bf32c31118618025e63957aac590
+  data.tar.gz: c08a6d413c210e044e609e36c1e297803476ff52e6b54c6bd8be48b89c4aeafc3b2d759da86314b84858d18fdf29ecb0c9fda2b1f8403bbdce44dfa829bd5aa0

data/README.md

@@ -15,36 +15,55 @@ Tweet.all.each do |tweet|
   p tweet.favorites.count
 end
 # SELECT `tweets`.* FROM `tweets`
-# SELECT COUNT(*) FROM `tweets` WHERE `tweets`.`tweet_id` = 1
-# SELECT COUNT(*) FROM `tweets` WHERE `tweets`.`tweet_id` = 2
-# SELECT COUNT(*) FROM `tweets` WHERE `tweets`.`tweet_id` = 3
-# SELECT COUNT(*) FROM `tweets` WHERE `tweets`.`tweet_id` = 4
-# SELECT COUNT(*) FROM `tweets` WHERE `tweets`.`tweet_id` = 5
+# SELECT COUNT(*) FROM `favorites` WHERE `favorites`.`tweet_id` = 1
+# SELECT COUNT(*) FROM `favorites` WHERE `favorites`.`tweet_id` = 2
+# SELECT COUNT(*) FROM `favorites` WHERE `favorites`.`tweet_id` = 3
+# SELECT COUNT(*) FROM `favorites` WHERE `favorites`.`tweet_id` = 4
+# SELECT COUNT(*) FROM `favorites` WHERE `favorites`.`tweet_id` = 5
 ```
 
 ### Count eager loading
 
+#### precount
+
 With activerecord-precount gem installed, you can use `precount` method
 to eagerly load counts of associated records.
+Like `preload`, it loads counts by multiple queries
 
 ```rb
 Tweet.all.precount(:favorites).each do |tweet|
   p tweet.favorites.count
 end
 # SELECT `tweets`.* FROM `tweets`
-# SELECT COUNT(`tweets`.`tweet_id`), tweet_id FROM `tweets` WHERE `tweets`.`tweet_id` IN (1, 2, 3, 4, 5) GROUP BY tweet_id
+# SELECT COUNT(`favorites`.`tweet_id`), `favorites`.`tweet_id` FROM `favorites` WHERE `favorites`.`tweet_id` IN (1, 2, 3, 4, 5) GROUP BY `favorites`.`tweet_id`
+```
+
+#### eager\_count
+
+Like `eager_load`, `eager_count` method allows you to load counts by one JOIN query.
+
+```rb
+Tweet.all.eager_count(:favorites).each do |tweet|
+  p tweet.favorites.count
+end
+# SELECT `tweets`.`id` AS t0_r0, `tweets`.`tweet_id` AS t0_r1, `tweets`.`user_id` AS t0_r2, `tweets`.`created_at` AS t0_r3, `tweets`.`updated_at` AS t0_r4, COUNT(`favorites`.`id`) AS t1_r0 FROM `tweets` LEFT OUTER JOIN `favorites` ON `favorites`.`tweet_id` = `tweets`.`id` GROUP BY tweets.id
 ```
 
 ## Benchmark
 
-With [this benchmark](https://github.com/k0kubun/activerecord-precount/blob/079c8fdaaca4e7f08f542f825e296183a3f19c67/benchmark.rb)
-([result](https://travis-ci.org/k0kubun/activerecord-precount/jobs/48996451)),
-precounted query is **7.7x faster** than N+1 count query.
+The [result](https://travis-ci.org/k0kubun/activerecord-precount/jobs/49061937) of
+[this benchmark](https://github.com/k0kubun/activerecord-precount/blob/40765d36ff0e0627cd0941b2c0a0f6573290c67e/benchmark.rb).
+
+|    | N+1 query | precount | eager\_count |
+|:-- |:----------|:---------|:-------------|
+| Time | 1.401 | 0.176 | 0.119 |
+| Ratio | 1.0x | **7.9x faster** | **11.7x faster** |
 
 ```rb
 # Tweet count is 50, and each tweet has 10 favorites
-Tweet.precount(:favorites).first(50).map(&:favorites_count) # 0.190
-Tweet.first(50).map{ |t| t.favorites.count }                # 1.472
+Tweet.all.map{ |t| t.favorites.count }                # N+1 query
+Tweet.precount(:favorites).map(&:favorites_count)     # precount
+Tweet.eager_count(:favorites).map(&:favorites_count)  # eager_count
 ```
 
 ## Installation
@@ -69,8 +88,8 @@ gem 'activerecord-precount'
 ## Advanced Usage
 
 ### Nested eager loading
-`Foo.precount(:bars)` automatically defines `bars_count` association for `Foo`.
-Thus you can preload the association and call `foo.bars_count`.
+`Foo.precount(:bars)` or `Foo.eager_count(:bars)` automatically defines `bars_count` association for `Foo`.
+That enables you to preload the association and call `foo.bars_count`.
 
 You can manually define `bars_count` with follwoing code.
 
@@ -103,9 +122,11 @@ Though precounted `bars.count` is faster than not-precounted one, the fallback i
 ```rb
 # slow
 Foo.precount(:bars).map { |f| f.bars.count }
+Foo.eager_count(:bars).map { |f| f.bars.count }
 
 # fast (recommended)
 Foo.precount(:bars).map { |f| f.bars_count }
+Foo.eager_count(:bars).map { |f| f.bars_count }
 ```
 
 ## License

data/benchmark.rb

@@ -8,8 +8,10 @@ require 'models/tweet'
 RBench.run(50) do
   column :counter_cache,          title: 'counter_cache'
   column :left_join,              title: 'LEFT JOIN'
-  column :count_loader,           title: 'precount'
-  column :precount,               title: 'slow precount'
+  column :eager_count,            title: 'eager_count'
+  column :precount,               title: 'precount'
+  column :slow_eager_count,       title: 'slow eager_count'
+  column :slow_precount,          title: 'slow precount'
   column :has_many,               title: 'preload'
   column :count_query,            title: 'N+1 COUNT'
 
@@ -17,6 +19,9 @@ RBench.run(50) do
     select('tweets.*, COUNT(favorites.id) AS joined_count').group('tweets.id')
 
   def prepare_records(tweets_count, favorites_count)
+    Tweet.delete_all
+    Favorite.delete_all
+
     tweets_count.times do
       t = Tweet.create(favorites_count_cache: 0)
       favorites_count.times { Favorite.create(tweet: t) }
@@ -34,12 +39,16 @@ RBench.run(50) do
     prepare_records(tweets_count, favorites_count)
 
     report "N = #{tweets_count}, count = #{favorites_count}" do
-      counter_cache          { Tweet.first(tweets_count).map(&:favorites_count_cache) }
-      left_join              { join_relation.first(tweets_count).map(&:joined_count) }
-      count_loader           { Tweet.precount(:favorites).first(tweets_count).map(&:favorites_count) }
-      precount               { Tweet.precount(:favorites).first(tweets_count).map { |t| t.favorites.count } }
-      has_many               { Tweet.preload(:favorites).first(tweets_count).map{ |t| t.favorites.size } }
-      count_query            { Tweet.first(tweets_count).map{ |t| t.favorites.count } }
+      counter_cache          { Tweet.all.map(&:favorites_count_cache) }
+      left_join              { Tweet.joins('LEFT JOIN favorites ON tweets.id = favorites.tweet_id').
+                               select('tweets.*, COUNT(favorites.id) AS joined_count').
+                               group('tweets.id').map(&:joined_count) }
+      eager_count            { Tweet.eager_count(:favorites).map(&:favorites_count) }
+      precount               { Tweet.precount(:favorites).map(&:favorites_count) }
+      slow_eager_count       { Tweet.eager_count(:favorites).map { |t| t.favorites.count } }
+      slow_precount          { Tweet.precount(:favorites).map { |t| t.favorites.count } }
+      has_many               { Tweet.preload(:favorites).map{ |t| t.favorites.size } }
+      count_query            { Tweet.all.map{ |t| t.favorites.count } }
     end
   end
 end

data/lib/active_record/precount/base_extension.rb

@@ -1,7 +1,7 @@
 module ActiveRecord
   module Precount
     module BaseExtension
-      delegate :precount, to: :all
+      delegate :precount, :eager_count, to: :all
 
       def has_reflection?(name)
         reflection_for(name).present?

data/lib/active_record/precount/join_dependency_extension.rb

@@ -1,22 +1,48 @@
 module ActiveRecord
-  # This imitates EagerLoadPolymorphicError
-  class EagerLoadCountLoaderError < ActiveRecordError
-    def initialize(reflection)
-      super("Cannot eagerly load the count_loader association #{reflection.name.inspect}")
-    end
-  end
-
   module Precount
     module JoinDependencyExtension
-      def build(associations, base_klass)
-        associations.map do |name, right|
-          reflection = find_reflection base_klass, name
-          if reflection.macro == :count_loader
-            raise EagerLoadCountLoaderError.new(reflection)
+      class CountTable < Associations::JoinDependency::Aliases::Table
+        def column_aliases
+          columns.map { |column| table[column.name].count.as Arel.sql column.alias }
+        end
+      end
+
+      def aliases
+        Associations::JoinDependency::Aliases.new join_root.each_with_index.map { |join_part,i|
+          if join_part.is_a?(Associations::JoinDependency::JoinAssociation) && join_part.reflection.macro == :count_loader
+            # select COUNT(primary_key)
+            column_name = join_part.reflection.klass.primary_key
+            column = Associations::JoinDependency::Aliases::Column.new column_name, "t#{i}_r0"
+            CountTable.new(join_part, [column])
+          else
+            # original aliases' internal function
+            columns = join_part.column_names.each_with_index.map { |column_name,j|
+              Associations::JoinDependency::Aliases::Column.new column_name, "t#{i}_r#{j}"
+            }
+            Associations::JoinDependency::Aliases::Table.new(join_part, columns)
           end
+        }
+      end
+
+      private
+
+      # instantiate only count_loader and pass others to super
+      def construct(ar_parent, parent, row, rs, seen, model_cache, aliases)
+        normal_children = []
+
+        parent.children.each do |node|
+          if node.reflection.macro != :count_loader
+            normal_children << node
+            next
+          end
+
+          key = aliases.column_alias(node, node.primary_key)
+          ar_parent.association(node.reflection.name).target = row[key].to_i
         end
+        return if normal_children.blank?
 
-        super(associations, base_klass)
+        normal_parent = Associations::JoinDependency::JoinBase.new(parent.base_klass, normal_children)
+        super(ar_parent, normal_parent, row, rs, seen, model_cache, aliases)
       end
     end
   end

data/lib/active_record/precount/relation_extension.rb

@@ -13,11 +13,23 @@ module ActiveRecord
         self
       end
 
+      def eager_count(*args)
+        check_if_method_has_arguments!(:eager_count, args)
+        spawn.eager_count!(*args)
+      end
+
+      def eager_count!(*args)
+        define_count_loader!(*args)
+
+        self.eager_load_values += args.map { |arg| :"#{arg}_count" }
+        self
+      end
+
       private
 
       def define_count_loader!(*args)
         args.each do |arg|
-          raise ArgumentError, "#{klass} does not have :#{arg} association." unless has_reflection?(arg)
+          raise ArgumentError, "Association named '#{arg}' was not found on #{klass.name}." unless has_reflection?(arg)
           next if has_reflection?(counter_name = :"#{arg}_count")
 
           options = reflection_for(arg).options.slice(*Associations::Builder::CountLoader.valid_options)
@@ -25,6 +37,20 @@ module ActiveRecord
           Reflection.add_reflection(model, counter_name, reflection)
         end
       end
+
+      def apply_join_dependency(relation, join_dependency)
+        relation = super(relation, join_dependency)
+
+        # to count associated records in JOIN query, group scope is necessary
+        join_dependency.reflections.each do |reflection|
+          if reflection.macro == :count_loader
+            ar = reflection.active_record
+            relation = relation.group("#{ar.table_name}.#{ar.primary_key}")
+          end
+        end
+
+        relation
+      end
     end
   end
 end

data/lib/active_record/precount/version.rb

@@ -1,5 +1,5 @@
 module ActiveRecord
   module Precount
-    VERSION = "0.4.3"
+    VERSION = "0.5.0"
   end
 end

data/sample/app/controllers/application_controller.rb

@@ -1,13 +1,33 @@
 class ApplicationController < ActionController::Base
+  AVAILABLE_LOADERS = %w[N+1 precount eager_count].freeze
+  DEFAULT_LOADER    = 'N+1'
+
   def index
     @tweets = Tweet.all
-    if eager_load?
+    case loader
+    when 'precount'
       @tweets = @tweets.precount(:replies).preload(in_reply_to: :favorites_count)
+    when 'eager_count'
+      @tweets = @tweets.eager_count(:replies).eager_load(in_reply_to: :favorites_count)
     end
   end
 
-  def eager_load?
-    params[:eager_load] == 'true'
+  def precount?
+    loader == 'precount'
+  end
+  helper_method :precount?
+
+  def eager_count?
+    loader == 'eager_count'
+  end
+  helper_method :eager_count?
+
+  def loader
+    if AVAILABLE_LOADERS.include?(params[:loader])
+      params[:loader]
+    else
+      DEFAULT_LOADER
+    end
   end
-  helper_method :eager_load?
+  helper_method :loader
 end

data/sample/app/views/application/index.html.erb

@@ -23,7 +23,7 @@
           <%= tweet.id %>
         </td>
         <td>
-          <%= tweet.replies.count %>
+          <%= (precount? || eager_count?) ? tweet.replies_count : tweet.replies.count %>
         </td>
         <td>
           <%= tweet.in_reply_to.try(:id) %>
@@ -38,12 +38,14 @@
 <% finish = Time.now %>
 
 <p>
-  <%= eager_load? ? 'Eager loaded' : 'N+1 query' %>
+  Loader: <%= loader %>
 </p>
 <p>
   Time: <%= "%.1f" % ((finish - start) * 1000) %>ms
 </p>
 
 <p>
-  <%= link_to 'Swtich', url_for(eager_load: !eager_load?) %>
-<p>
+  <% ApplicationController::AVAILABLE_LOADERS.each do |ld| %>
+    <%= link_to_unless loader == ld, ld, url_for(loader: ld) %>
+  <% end %>
+</p>

data/sample/db/migrate/20141122002518_create_tweets.rb

@@ -6,5 +6,6 @@ class CreateTweets < ActiveRecord::Migration
 
       t.timestamps
     end
+    add_index :tweets, :in_reply_to_tweet_id
   end
 end

data/sample/db/migrate/20141122002548_create_favorites.rb

@@ -6,5 +6,6 @@ class CreateFavorites < ActiveRecord::Migration
 
       t.timestamps
     end
+    add_index :favorites, :tweet_id
   end
 end

data/sample/db/schema.rb

@@ -20,6 +20,8 @@ ActiveRecord::Schema.define(version: 20141122002555) do
     t.datetime "updated_at"
   end
 
+  add_index "favorites", ["tweet_id"], name: "index_favorites_on_tweet_id", using: :btree
+
   create_table "tweets", force: :cascade do |t|
     t.integer  "in_reply_to_tweet_id", limit: 4
     t.integer  "user_id",              limit: 4
@@ -27,6 +29,8 @@ ActiveRecord::Schema.define(version: 20141122002555) do
     t.datetime "updated_at"
   end
 
+  add_index "tweets", ["in_reply_to_tweet_id"], name: "index_tweets_on_in_reply_to_tweet_id", using: :btree
+
   create_table "users", force: :cascade do |t|
     t.datetime "created_at"
     t.datetime "updated_at"

data/test/cases/associations/eager_count_test.rb

@@ -0,0 +1,46 @@
+require 'cases/helper'
+
+class EagerCountTest < ActiveRecord::CountLoader::TestCase
+  def setup
+    tweets_count.times.map do |index|
+      tweet = Tweet.create
+      index.times { Favorite.create(tweet: tweet) }
+    end
+
+    if Tweet.has_reflection?(:favs_count)
+      if ActiveRecord::VERSION::MAJOR >= 4 && ActiveRecord::VERSION::MINOR >= 2
+        Tweet._reflections.delete('favs_count')
+      else
+        Tweet._reflections.delete(:favs_count)
+      end
+    end
+  end
+
+  def teardown
+    [Tweet, Favorite].each(&:delete_all)
+  end
+
+  def tweets_count
+    3
+  end
+
+  def test_eager_count_defines_count_loader
+    assert_equal(Tweet.has_reflection?(:favs_count), false)
+    Tweet.eager_count(:favs).map(&:favs_count)
+    assert_equal(Tweet.has_reflection?(:favs_count), true)
+  end
+
+  def test_eager_count_has_many_with_count_loader_does_not_execute_n_1_queries
+    assert_queries(1 + tweets_count) { Tweet.all.map { |t| t.favorites.count } }
+    assert_queries(1 + tweets_count) { Tweet.all.map(&:favorites_count) }
+    assert_queries(1) { Tweet.eager_count(:favorites).map { |t| t.favorites.count } }
+    assert_queries(1) { Tweet.eager_count(:favorites).map(&:favorites_count) }
+  end
+
+  def test_eager_count_has_many_counts_properly
+    expected = Tweet.order(id: :asc).map { |t| t.favorites.count }
+    assert_equal(Tweet.order(id: :asc).map(&:favorites_count), expected)
+    assert_equal(Tweet.order(id: :asc).eager_count(:favorites).map { |t| t.favorites.count }, expected)
+    assert_equal(Tweet.order(id: :asc).eager_count(:favorites).map(&:favorites_count), expected)
+  end
+end

data/test/cases/associations/eager_load_test.rb

@@ -4,17 +4,30 @@ require 'models/tweet'
 
 class EagerLoadTest < ActiveRecord::CountLoader::TestCase
   def setup
-    tweet = Tweet.create
-    Favorite.create(tweet: tweet)
+    tweets_count.times.map do |index|
+      tweet = Tweet.create
+      index.times { Favorite.create(tweet: tweet) }
+    end
   end
 
   def teardown
     [Tweet, Favorite].each(&:delete_all)
   end
 
-  def test_eager_loaded_count_loader_raises_an_error
-    assert_raises ActiveRecord::EagerLoadCountLoaderError do
-      Tweet.eager_load(:favorites_count).to_a
-    end
+  def tweets_count
+    3
+  end
+
+  def test_eager_load_does_not_execute_n_1_queries
+    assert_queries(1 + tweets_count) { Tweet.all.map { |t| t.favorites.count } }
+    assert_queries(1 + tweets_count) { Tweet.all.map(&:favorites_count) }
+    assert_queries(1) { Tweet.eager_load(:favorites_count).map(&:favorites_count) }
+  end
+
+  def test_eager_loaded_count_loader_counts_properly
+    expected = Tweet.order(id: :asc).map { |t| t.favorites.count }
+    assert_equal(Tweet.order(id: :asc).map(&:favorites_count), expected)
+    assert_equal(Tweet.order(id: :asc).eager_load(:favorites_count).map { |t| t.favorites.count }, expected)
+    assert_equal(Tweet.order(id: :asc).eager_load(:favorites_count).map(&:favorites_count), expected)
   end
 end

data/test/cases/associations/precount_test.rb

@@ -6,6 +6,14 @@ class PrecountTest < ActiveRecord::CountLoader::TestCase
       tweet = Tweet.create
       index.times { Favorite.create(tweet: tweet) }
     end
+
+    if Tweet.has_reflection?(:favs_count)
+      if ActiveRecord::VERSION::MAJOR >= 4 && ActiveRecord::VERSION::MINOR >= 2
+        Tweet._reflections.delete('favs_count')
+      else
+        Tweet._reflections.delete(:favs_count)
+      end
+    end
   end
 
   def teardown
@@ -16,11 +24,10 @@ class PrecountTest < ActiveRecord::CountLoader::TestCase
     3
   end
 
-  def test_precount_has_many_does_not_execute_n_1_queries
-    assert_equal(Tweet.reflections['favs_count'].present?, false)
-    assert_queries(1 + tweets_count) { Tweet.all.map { |t| t.favs.count } }
-    assert_queries(2) { Tweet.precount(:favs).map { |t| t.favs.count } }
-    assert_queries(2) { Tweet.precount(:favs).map(&:favs_count) }
+  def test_precount_defines_count_loader
+    assert_equal(Tweet.has_reflection?(:favs_count), false)
+    Tweet.precount(:favs).map(&:favs_count)
+    assert_equal(Tweet.has_reflection?(:favs_count), true)
   end
 
   def test_precount_has_many_with_count_loader_does_not_execute_n_1_queries
@@ -33,6 +40,7 @@ class PrecountTest < ActiveRecord::CountLoader::TestCase
   def test_precount_has_many_counts_properly
     expected = Tweet.all.map { |t| t.favorites.count }
     assert_equal(Tweet.all.map(&:favorites_count), expected)
+    assert_equal(Tweet.precount(:favorites).map { |t| t.favorites.count }, expected)
     assert_equal(Tweet.precount(:favorites).map(&:favorites_count), expected)
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-precount
 version: !ruby/object:Gem::Version
-  version: 0.4.3
+  version: 0.5.0
 platform: ruby
 authors:
 - Takashi Kokubun
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-01-31 00:00:00.000000000 Z
+date: 2015-02-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -251,6 +251,7 @@ files:
 - sample/public/robots.txt
 - sample/vendor/assets/javascripts/.keep
 - sample/vendor/assets/stylesheets/.keep
+- test/cases/associations/eager_count_test.rb
 - test/cases/associations/eager_load_test.rb
 - test/cases/associations/includes_test.rb
 - test/cases/associations/precount_test.rb