activerecord-precount 0.4.2 → 0.4.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 558ab186a4ad75d87bd48d8035248b0a72170a33
-  data.tar.gz: 41746e4e827dfa0bb315730e0827682efef19072
+  metadata.gz: 03bcfbd6e4eeb0e73abd3ba62ce3479ce88be195
+  data.tar.gz: ed4a627ba81085af77fc6c0fc0c5036d6aed498b
 SHA512:
-  metadata.gz: 03436420d1477fe170c6768e9b06f4c4b9ced3bd4ed4c91584023d00a88f789c8d204cab60701b3f3e8f0ee6027626b47ab62ca3c80581414b0e613ff0f61f4d
-  data.tar.gz: 6c7ce07a028ff757ba67fe6620de75204fa67c5d29f503569839c412890a412996c9e2345938b5fabb763339d27a6f41a7e7ee8eca1e16bfa82c17dfe37e697d
+  metadata.gz: 9ec150f0c07963351a74c8657673bb14a3afe9e4476c19658ea74a1e489b89e21f5abc876aa097c703460db396069cacf54bfd7a70ab0e536c9a20c953d5a46f
+  data.tar.gz: 0c50e140ed0cfb414f64c380e3fd95c92083a207e2b2dbf144536d285d24bc1c23ded87944eeb74ecce362aa493c818b5fc0097621e9ea32902b7eb73f8433bf

data/README.md

@@ -32,7 +32,19 @@ Tweet.all.precount(:favorites).each do |tweet|
   p tweet.favorites.count
 end
 # SELECT `tweets`.* FROM `tweets`
-# SELECT `tweets`.`in_reply_to_tweet_id` FROM `tweets` WHERE `tweets`.`tweet_id` IN (1, 2, 3, 4, 5)
+# SELECT COUNT(`tweets`.`tweet_id`), tweet_id FROM `tweets` WHERE `tweets`.`tweet_id` IN (1, 2, 3, 4, 5) GROUP BY tweet_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.
+
+```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
 ```
 
 ## Installation
@@ -54,16 +66,48 @@ gem 'activerecord-precount'
   - mysql
   - postgresql
 
-## Testing
+## 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`.
+
+You can manually define `bars_count` with follwoing code.
+
+```diff
+ class Foo < ActiveRecord::Base
+-  has_many :bars
++  has_many :bars, count_loader: true
+ end
+```
+
+Then there are two different ways to preload the `bars_count`.
+
+```rb
+# the same
+Foo.preload(:bars_count)
+Foo.precount(:bars)
+```
+
+With this condition, you can eagerly load nested association by preload.
+
+```rb
+Hoge.preload(foo: :bars_count)
+```
+
+### Performance issue
+
+With activerecord-precount gem installed, `bars.count` fallbacks to `bars_count` if `bars_count` is defined.
+Though precounted `bars.count` is faster than not-precounted one, the fallback is currently much slower than just calling `bars_count`.
+
+```rb
+# slow
+Foo.precount(:bars).map { |f| f.bars.count }
 
-```bash
-$ bundle exec rake
+# fast (recommended)
+Foo.precount(:bars).map { |f| f.bars_count }
 ```
 
-## Contributing
+## License
 
-1. Fork it ( https://github.com/k0kubun/activerecord-precount/fork )
-2. Create your feature branch (`git checkout -b my-new-feature`)
-3. Commit your changes (`git commit -am 'Add some feature'`)
-4. Push to the branch (`git push origin my-new-feature`)
-5. Create a new Pull Request
+MIT License

data/benchmark.rb

@@ -8,8 +8,9 @@ require 'models/tweet'
 RBench.run(50) do
   column :counter_cache,          title: 'counter_cache'
   column :left_join,              title: 'LEFT JOIN'
-  column :count_loader,           title: 'precount has_many'
-  column :has_many,               title: 'preload has_many'
+  column :count_loader,           title: 'precount'
+  column :precount,               title: 'slow precount'
+  column :has_many,               title: 'preload'
   column :count_query,            title: 'N+1 COUNT'
 
   join_relation = Tweet.joins('LEFT JOIN favorites ON tweets.id = favorites.tweet_id').
@@ -26,6 +27,7 @@ RBench.run(50) do
     [10, 5],
     [20, 20],
     [30, 100],
+    [50, 10],
   ]
 
   test_cases.each do |tweets_count, favorites_count|
@@ -34,7 +36,8 @@ RBench.run(50) do
     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.preload(:favorites_count).first(tweets_count).map(&:favorites_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 } }
     end

data/lib/active_record/associations/preloader/count_loader.rb

@@ -14,10 +14,7 @@ module ActiveRecord
 
         def preload(preloader)
           associated_records_by_owner(preloader).each do |owner, associated_records|
-            count = associated_records.count
-
-            association = owner.association(reflection.name)
-            association.target = count
+            owner.association(reflection.name).target = associated_records.first.to_i
           end
         end
 
@@ -26,14 +23,13 @@ module ActiveRecord
             records_for(slice)
           }
 
-          @preloaded_records.map { |record|
-            key = record
-            [record, key]
+          @preloaded_records.first.map { |key, count|
+            [count, key]
           }
         end
 
         def query_scope(ids)
-          scope.where(association_key.in(ids)).pluck(association_key_name)
+          scope.where(association_key.in(ids)).group(association_key_name).count(association_key_name)
         end
       end
     end

data/lib/active_record/precount/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-precount
 version: !ruby/object:Gem::Version
-  version: 0.4.2
+  version: 0.4.3
 platform: ruby
 authors:
 - Takashi Kokubun