activerecord-precount 0.4.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 1621a4f3c4f5d53c03ad4f6e2a62e9e23119a734
+  data.tar.gz: c0c2e63f3ef20f39f98ca38a0339395212597104
+SHA512:
+  metadata.gz: 9a29284daa7c6fa23bb26cdc713fa7a9b71449a19bbd65b89eb7e48fe664c0dfe54fc3c64e38ee4227de8122728ed3421a6cb1287f73596593bf7f6d8c2c7c47
+  data.tar.gz: a07629cc1a93ccb7c250d74a1be50f7c143f615b32785eeaae059a56ec5dc1d0b19ad2cb7964de2a3af68cf190c6e8a5706e69c91f4b529effd8645a20997352

data/.gitignore

@@ -0,0 +1,19 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.sqlite3
+test/config.yml

data/.travis.yml

@@ -0,0 +1,28 @@
+script: ci/travis.rb
+language: ruby
+sudo: false
+matrix:
+  include:
+    - rvm: 2.0
+      env: TASK=test ARCONN=mysql2
+      gemfile: ci/Gemfile.activerecord-4.2.x
+    - rvm: 2.1
+      env: TASK=test ARCONN=mysql2
+      gemfile: ci/Gemfile.activerecord-4.2.x
+    - rvm: 2.2
+      env: TASK=test ARCONN=mysql2
+      gemfile: ci/Gemfile.activerecord-4.1.x
+    - rvm: 2.2
+      env: TASK=test ARCONN=sqlite3
+      gemfile: ci/Gemfile.activerecord-4.2.x
+    - rvm: 2.2
+      env: TASK=test ARCONN=mysql2
+      gemfile: ci/Gemfile.activerecord-4.2.x
+    - rvm: 2.2
+      env: TASK=test ARCONN=postgresql
+      gemfile: ci/Gemfile.activerecord-4.2.x
+    - rvm: 2.2
+      env: TASK=benchmark ARCONN=mysql2
+      gemfile: ci/Gemfile.activerecord-4.2.x
+  allow_failures:
+    - env: TASK=benchmark ARCONN=mysql2

data/Gemfile

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in activerecord-precount.gemspec
+gemspec
+
+gem 'rbench', github: 'miloops/rbench'

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Takashi Kokubun
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,91 @@
+# ActiveRecord::Precount [![Build Status](https://travis-ci.org/k0kubun/activerecord-precount.svg?branch=master)](https://travis-ci.org/k0kubun/activerecord-precount)
+
+N+1 count query killer for ActiveRecord.  
+ActiveRecord::Precount allows you to cache count of associated records by eager loading.
+
+## Why ActiveRecord::Precount?
+Rails provides a way to resolve N+1 count query, which is [belongs\_to's counter\_cache option](http://guides.rubyonrails.org/association_basics.html#counter-cache).  
+It requires a column to cache the count. But adding a column just for count cache is overkill.  
+  
+Thus this plugin enables you to preload counts in the same way as `has_many` and `belongs_to`.  
+`count_loader` is an ActiveRecord's association, which is preloadable by `preload` or `includes`.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'activerecord-precount'
+```
+
+## Usage
+
+### Enable count\_loader option
+First, enable your has\_many association's count\_loader option.
+
+```diff
+ class Tweet
+-  has_many :favorites
++  has_many :favorites, count_loader: true
+ end
+```
+
+The option defines an additional association whose name is `favorites_count`.  
+Its association type is not an ordinary one (i.e. `has_many`, `belongs_to`) but `count_loader`.
+
+### Preload the association
+This association works well by default.
+
+```rb
+@tweets = Tweet.all
+@tweets.each do |tweet|
+  p tweets.favorites_count # same as tweets.favorites.count
+end
+```
+
+You can eagerly load `count_loader` association by `includes` or `preload`.
+
+```rb
+@tweets = Tweet.all.preload(:favorites_count)
+@tweets.each do |tweet|
+  p tweets.favorites_count # this line doesn't execute an additional query
+end
+```
+
+Since it is association, you can preload nested `count_loader` association.
+
+```rb
+@users = User.all.preload(tweets: :favorites_count)
+@users.each do |user|
+  user.tweets.each do |tweet|
+    p tweet.favorites_count # this line doesn't execute an additional query
+  end
+end
+```
+
+## Supported Versions
+
+- Ruby
+  - 2.0, 2.1, 2.2
+- Rails
+  - 4.1, 4.2
+
+### Databases
+
+- sqlite
+- mysql
+- postgresql
+
+## Testing
+
+```bash
+$ bundle exec rake
+```
+
+## Contributing
+
+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

data/Rakefile

@@ -0,0 +1,14 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+desc 'Run count_loader benchmarks'
+task :benchmark do
+  ruby('benchmark.rb')
+end
+
+Rake::TestTask.new do |t|
+  t.libs << "lib" << "test"
+  t.test_files = Dir.glob("test/**/*_test.rb")
+end
+
+task default: :test

data/activerecord-precount.gemspec

@@ -0,0 +1,31 @@
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'active_record/precount/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "activerecord-precount"
+  spec.version       = ActiveRecord::Precount::VERSION
+  spec.authors       = ["Takashi Kokubun"]
+  spec.email         = ["takashikkbn@gmail.com"]
+  spec.summary       = %q{N+1 count query killer for ActiveRecord}
+  spec.description   = %q{N+1 count query killer for ActiveRecord}
+  spec.homepage      = "https://github.com/k0kubun/activerecord-precount"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.test_files    = spec.files.grep(%r{^spec/})
+  spec.require_paths = ["lib"]
+
+  spec.required_ruby_version = ">= 2.0"
+  spec.add_runtime_dependency "activerecord", ">= 3.2.0"
+  spec.add_development_dependency "minitest"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "erubis"
+  spec.add_development_dependency "bundler"
+  spec.add_development_dependency "pry"
+  spec.add_development_dependency "sqlite3"
+  spec.add_development_dependency "mysql2"
+  spec.add_development_dependency "postgres"
+  spec.add_development_dependency "rbench"
+  spec.add_development_dependency "dalli"
+end

data/benchmark.rb

@@ -0,0 +1,42 @@
+$LOAD_PATH.unshift File.expand_path('../test', __FILE__)
+
+require 'rbench'
+require 'cases/db_config'
+require 'models/favorite'
+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_query,            title: 'N+1 COUNT'
+
+  join_relation = Tweet.joins('LEFT JOIN favorites ON tweets.id = favorites.tweet_id').
+    select('tweets.*, COUNT(favorites.id) AS joined_count').group('tweets.id')
+
+  def prepare_records(tweets_count, favorites_count)
+    tweets_count.times do
+      t = Tweet.create(favorites_count_cache: 0)
+      favorites_count.times { Favorite.create(tweet: t) }
+    end
+  end
+
+  test_cases = [
+    [10, 5],
+    [20, 20],
+    [30, 100],
+  ]
+
+  test_cases.each do |tweets_count, favorites_count|
+    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.preload(:favorites_count).first(tweets_count).map(&: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
+  end
+end

data/ci/Gemfile.activerecord-4.1.x

@@ -0,0 +1,4 @@
+source "https://rubygems.org"
+
+gem 'rails', '~> 4.1.0'
+gemspec path: '..'

data/ci/Gemfile.activerecord-4.2.x

@@ -0,0 +1,4 @@
+source "https://rubygems.org"
+
+gem 'rails', '~> 4.2.0'
+gemspec path: '..'

data/ci/travis.rb

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+commands = [
+  'mysql -e "create database activerecord_unittest;"',
+  'mysql -e "create database activerecord_unittest2;"',
+  'psql  -c "create database activerecord_unittest;" -U postgres',
+  'psql  -c "create database activerecord_unittest2;" -U postgres'
+]
+
+commands.each do |command|
+  system("#{command} > /dev/null 2>&1")
+end
+
+exit system("bundle exec rake $TASK")

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

@@ -0,0 +1,13 @@
+module ActiveRecord::Associations::Builder
+  class CountLoader < SingularAssociation
+    self.valid_options = [:class, :class_name, :foreign_key]
+
+    def macro
+      :count_loader
+    end
+
+    def self.valid_dependent_options
+      []
+    end
+  end
+end

data/lib/active_record/associations/count_loader.rb

@@ -0,0 +1,27 @@
+module ActiveRecord
+  module Associations
+    class CountLoader < SingularAssociation
+      # Not preloaded behaviour of count_loader association
+      # When this method is called, it will be N+1 query
+      def load_target
+        count_target = reflection.name_without_count.to_sym
+        @target = owner.association(count_target).count
+
+        loaded! unless loaded?
+        target
+      rescue ActiveRecord::RecordNotFound
+        reset
+      end
+    end
+  end
+
+  module Reflection
+    class CountLoaderReflection < AssociationReflection
+      def initialize(name, scope, options, active_record)
+        super(name, scope, options, active_record)
+      end
+
+      def macro; :count_loader; end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+module ActiveRecord
+  module Associations
+    class Preloader
+      class CountLoader < SingularAssociation
+        def association_key_name
+          reflection.foreign_key
+        end
+
+        def owner_key_name
+          reflection.active_record_primary_key
+        end
+
+        private
+
+        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
+          end
+        end
+
+        def load_slices(slices)
+          @preloaded_records = slices.flat_map { |slice|
+            records_for(slice)
+          }
+
+          @preloaded_records.map { |record|
+            key = record
+            [record, key]
+          }
+        end
+
+        def query_scope(ids)
+          scope.where(association_key.in(ids)).pluck(association_key_name)
+        end
+      end
+    end
+  end
+end

data/lib/active_record/precount/base_extension.rb

@@ -0,0 +1,7 @@
+module ActiveRecord
+  module Precount
+    module BaseExtension
+      delegate :precount, to: :all
+    end
+  end
+end

data/lib/active_record/precount/extend.rb

@@ -0,0 +1,18 @@
+require "active_record/precount/base_extension"
+require "active_record/precount/has_many_extension"
+require "active_record/precount/join_dependency_extension"
+require "active_record/precount/preloader_extension"
+require "active_record/precount/reflection_extension"
+require "active_record/precount/relation_extension"
+
+ActiveSupport.on_load(:active_record) do
+  module ActiveRecord
+    Base.send(:extend, Precount::BaseExtension)
+    Relation.send(:prepend, Precount::RelationExtension)
+    Reflection.send(:prepend, Precount::ReflectionExtension)
+    Associations::Preloader.send(:prepend, Precount::PreloaderExtension)
+    Associations::JoinDependency.send(:prepend, Precount::JoinDependencyExtension)
+    Associations::Builder::HasMany.send(:prepend, Precount::Builder::HasManyExtension)
+    Reflection::AssociationReflection.send(:prepend, Precount::AssociationReflectionExtension)
+  end
+end

data/lib/active_record/precount/has_many_extension.rb

@@ -0,0 +1,25 @@
+module ActiveRecord
+  module Precount
+    module Builder
+      module HasManyExtension
+        def valid_options
+          super + [:count_loader]
+        end
+
+        def build(model)
+          define_count_loader(model) if options[:count_loader]
+          super
+        end
+
+        def define_count_loader(model)
+          name_with_count = :"#{name}_count"
+          name_with_count = options[:count_loader] if options[:count_loader].is_a?(Symbol)
+
+          valid_options = options.slice(*Associations::Builder::CountLoader.valid_options)
+          reflection = Associations::Builder::CountLoader.build(model, name_with_count, nil, valid_options)
+          Reflection.add_reflection(model, name_with_count, reflection)
+        end
+      end
+    end
+  end
+end