activerecord-has_count 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1638ba180bf14cd976c29912e38505fb21b73a4b
-  data.tar.gz: dd52048a4744eb4f5b740b0b0df9ca74f8a8eb99
+  metadata.gz: 69e774d016a1d4b507eb55f8f0f9504cbf198a3b
+  data.tar.gz: abbd2d57baa8ebdf82d65ce8f6080febafaaaf57
 SHA512:
-  metadata.gz: c3e3313087b1e78e6ef21b26c938a4ebe17124c74ac9c596970f4614e329f7f89375f1bdf3c2586b6dcd068f0e3ed705ccb38526ddb8b2d59e7635d6e8179930
-  data.tar.gz: 8128b246278b8c678a7fd8a52588e570444555e8e5362a0636cdb86170b77e92c8e2a3695035d393daa485ef7aad6d812ef62ddd923c64ce8065f1d9500bbcec
+  metadata.gz: 7ef3dacda31025b0d12def2faa3b14a75b43ab114a0389489a7962bc0e1c53542402991e0809198192ba8c28cc77c0bfd56c7533f79ca05a5cc6fe0406c65b94
+  data.tar.gz: 30460a520bfd15c0f131ec19091415976834fb0b876bc4c362148bc604f34a71827b39e76e33f00d1f07d03f8e4148e1e480191829e007ad4daad26dad74a73c

data/.gitignore

@@ -15,3 +15,4 @@ spec/reports
 test/tmp
 test/version_tmp
 tmp
+*.sqlite3

data/.rspec

@@ -0,0 +1 @@
+-c

data/.travis.yml

@@ -0,0 +1,7 @@
+rvm:
+- 2.0.0
+branches:
+  only:
+    - master
+script:
+  - "bundle exec rspec"

data/README.md

@@ -1,4 +1,4 @@
-# ActiveRecord::HasCount
+# ActiveRecord::HasCount [![Build Status](https://travis-ci.org/k0kubun/activerecord-has_count.png?branch=master)](https://travis-ci.org/k0kubun/activerecord-has_count)
 
 N+1 count query killer for ActiveRecord  
 ActiveRecord::HasCount allows you to cache count of associated records by eager loading
@@ -20,7 +20,7 @@ gem 'activerecord-has_count'
 
 ## Usage
 
-### Add count\_preloadable scope
+### Add has\_count scope
 First, call `has_count` with an association whose count you want to preload
 
 ```rb
@@ -63,7 +63,7 @@ end
 
 ## Contributing
 
-1. Fork it ( https://github.com/k0kubun/has_count/fork )
+1. Fork it ( https://github.com/k0kubun/activerecord-has_count/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`)

data/activerecord-has_count.gemspec

@@ -1,6 +1,6 @@
 lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'active_record/has_count/version'
+require 'activerecord-has_count/version'
 
 Gem::Specification.new do |spec|
   spec.name          = "activerecord-has_count"
@@ -17,7 +17,7 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   spec.required_ruby_version = ">= 1.9.2"
-  spec.add_runtime_dependency "activerecord", ">= 3.0"
+  spec.add_runtime_dependency "activerecord", ">= 3.2.0"
   spec.add_development_dependency "rspec", "~> 3.0.0"
   spec.add_development_dependency "factory_girl", "~> 4.2.0"
   spec.add_development_dependency "sqlite3"

data/benchmarks/Gemfile

@@ -0,0 +1,9 @@
+source 'https://rubygems.org'
+
+gem_dir = File.expand_path("../../", __FILE__)
+
+gem "activerecord", "~> 4.0"
+gem "activerecord-import"
+gem "activerecord-has_count", path: gem_dir
+gem "pry"
+gem "mysql2"

data/benchmarks/README.md

@@ -0,0 +1,16 @@
+# N+1 COUNT query benchmarks
+
+## Preparation
+
+```bash
+$ git clone git@github.com:k0kubun/activerecord-has_count
+$ cd activerecord-has_count
+$ mysql -uroot -e"create database bench"
+$ bundle install
+```
+
+## Run
+
+```bash
+$ bundle exec ruby benchmark.rb
+```

data/benchmarks/benchmark.rb

@@ -0,0 +1,60 @@
+require "benchmark"
+require "active_record"
+require "activerecord-import"
+require "activerecord-has_count"
+
+spec_dir = File.expand_path("../../spec", __FILE__)
+Dir[File.join(spec_dir, "models/*.rb")].each { |f| require f }
+
+database_yml = File.join(spec_dir, "database.yml")
+ActiveRecord::Base.configurations["bench"] = YAML.load_file(database_yml)["bench"]
+ActiveRecord::Base.establish_connection :bench
+
+ActiveRecord::Schema.define do
+  create_table :tweets, force: true do |t|
+    t.column :created_at, :datetime
+    t.column :updated_at, :datetime
+  end
+
+  create_table :replies, force: true do |t|
+    t.column :tweet_id, :integer
+    t.column :created_at, :datetime
+    t.column :updated_at, :datetime
+  end
+end
+
+[Tweet, Reply].each(&:delete_all)
+
+TWEET_COUNT = 5
+REPLY_COUNT = 10000
+
+TWEET_COUNT.times do
+  tweet = Tweet.create
+
+  replies = REPLY_COUNT.times.map do
+    Reply.new(tweet: tweet)
+  end
+  Reply.import(replies, validate: false)
+end
+
+Benchmark.bmbm do |bench|
+  bench.report("COUNT association") do
+    tweets = Tweet.first(TWEET_COUNT)
+
+    tweets.each { |t| t.replies.count }
+  end
+
+  bench.report("LEFT JOIN") do
+    tweets = Tweet.joins('LEFT JOIN replies ON tweets.id = replies.tweet_id').
+      select('tweets.*, COUNT(replies.id) AS replies_count').
+      group('tweets.id').first(TWEET_COUNT)
+
+    tweets.each { |t| t.replies_count }
+  end
+
+  bench.report("size of preloaded association") do
+    tweets = Tweet.preload(:replies).first(TWEET_COUNT)
+
+    tweets.each { |t| t.replies.size }
+  end
+end

data/lib/active_record/associations/has_count.rb

@@ -1,20 +1,7 @@
 module ActiveRecord
   module Associations
-    module ClassMethods
-      module HasCount
-        private
-
-        def has_count(name, scope = nil, options = {}, &extension)
-          name_with_count = :"#{name}_count"
-
-          reflection = Builder::HasCount.build(self, name_with_count, scope, options, &extension)
-          Reflection.add_reflection(self, name_with_count, reflection)
-        end
-      end
-    end
-
     class HasCount < SingularAssociation
-      # Not preloaded behaviour of count_preloadable association
+      # Not preloaded behaviour of has_count association
       # When this method is called, it will be N+1 query
       def load_target
         count_target = name_without_count.to_sym

data/lib/activerecord-has_count/model.rb

@@ -0,0 +1,23 @@
+module ActiveRecord
+  module HasCount
+    module Model
+      def self.included(model)
+        model.singleton_class.class_eval do
+          include ClassMethods
+        end
+      end
+
+      module ClassMethods
+        private
+
+        def has_count(name, scope = nil, options = {}, &extension)
+          name_with_count = :"#{name}_count"
+
+          reflection = ActiveRecord::Associations::Builder::HasCount.
+            build(self, name_with_count, scope, options, &extension)
+          ActiveRecord::Reflection.add_reflection(self, name_with_count, reflection)
+        end
+      end
+    end
+  end
+end

data/lib/{active_record/has_count → activerecord-has_count}/version.rb

@@ -1,5 +1,5 @@
 module ActiveRecord
   module HasCount
-    VERSION = "0.0.1"
+    VERSION = "0.0.2"
   end
 end

data/lib/activerecord-has_count.rb

@@ -1,15 +1,15 @@
+require "active_record"
+require "active_support/lazy_load_hooks"
+
 require "active_record/associations/has_count"
 require "active_record/associations/builder/has_count"
 require "active_record/associations/preloader/has_count"
 require "active_record/associations/join_dependency/has_count"
 require "active_record/reflection/has_count"
 
-module ActiveRecord
-  module Associations
-    module ClassMethods
-      include HasCount
-    end
-  end
+ActiveSupport.on_load(:active_record) do
+  require "activerecord-has_count/model"
+  ActiveRecord::Base.send(:include, ActiveRecord::HasCount::Model)
 end
 
 module ActiveRecord

data/spec/database.yml

@@ -0,0 +1,13 @@
+test:
+  adapter: sqlite3
+  database: test.sqlite3
+  pool: 5
+  timeout: 5000
+bench:
+  adapter: mysql2
+  encoding: utf8
+  database: bench
+  pool: 5
+  username: root
+  password:
+  socket: /tmp/mysql.sock

data/spec/eager_load_spec.rb

@@ -0,0 +1,28 @@
+require "spec_helper"
+
+describe "#eager_load" do
+  describe "has_count association" do
+    let(:tweets_count) { 3 }
+    let(:tweets) do
+      tweets_count.times.map do
+        FactoryGirl.create(:tweet)
+      end
+    end
+
+    before do
+      tweets.each_with_index do |tweet, index|
+        index.times do
+          FactoryGirl.create(:reply, tweet: tweet)
+        end
+      end
+    end
+
+    it "raises ActiveRecord::EagerLoadHasCountError" do
+      # Currently this is not supported because I can't come up with how to implement.
+      # I'm waiting for your contribution.
+      expect {
+        Tweet.all.eager_load(:replies_count).map(&:replies_count)
+      }.to raise_error(ActiveRecord::EagerLoadHasCountError)
+    end
+  end
+end

data/spec/includes_spec.rb

@@ -0,0 +1,57 @@
+require "spec_helper"
+
+describe "#includes" do
+  describe "builtin associations" do
+    let(:replies_count) { 3 }
+    let!(:tweet) { FactoryGirl.create(:tweet) }
+    before do
+      replies_count.times do
+        FactoryGirl.create(:reply, tweet: tweet)
+      end
+    end
+
+    context "given has_many association" do
+      it "works as usual" do
+        tweet = Tweet.includes(:replies).first
+        expect(tweet.replies.count).to eq(replies_count)
+      end
+    end
+
+    context "given belongs_to association" do
+      let!(:reply) { FactoryGirl.create(:reply, tweet: tweet) }
+
+      it "works as usual" do
+        included_reply = Reply.includes(:tweet).find(reply.id)
+        expect(included_reply.tweet).to eq(tweet)
+      end
+    end
+  end
+
+  describe "has_count association" do
+    let(:tweets_count) { 3 }
+    let(:tweets) do
+      tweets_count.times.map do
+        FactoryGirl.create(:tweet)
+      end
+    end
+
+    before do
+      tweets.each_with_index do |tweet, index|
+        index.times do
+          FactoryGirl.create(:reply, tweet: tweet)
+        end
+      end
+    end
+
+    it "does not execute N+1 queries by preload" do
+      expect_query_counts(1 + tweets_count) { Tweet.all.map(&:replies_count) }
+      expect_query_counts(2) { Tweet.all.includes(:replies_count).map(&:replies_count) }
+    end
+
+    it "counts properly" do
+      expected = Tweet.all.map { |t| t.replies.count }
+      expect(Tweet.all.map(&:replies_count)).to eq(expected)
+      expect(Tweet.all.includes(:replies_count).map(&:replies_count)).to eq(expected)
+    end
+  end
+end

data/spec/models/reply.rb

@@ -0,0 +1,3 @@
+class Reply < ActiveRecord::Base
+  belongs_to :tweet
+end

data/spec/models/tweet.rb

@@ -0,0 +1,4 @@
+class Tweet < ActiveRecord::Base
+  has_many :replies
+  has_count :replies
+end

data/spec/preload_spec.rb

@@ -0,0 +1,57 @@
+require "spec_helper"
+
+describe "#preload" do
+  describe "builtin associations" do
+    let(:replies_count) { 3 }
+    let!(:tweet) { FactoryGirl.create(:tweet) }
+    before do
+      replies_count.times do
+        FactoryGirl.create(:reply, tweet: tweet)
+      end
+    end
+
+    context "given has_many association" do
+      it "works as usual" do
+        tweet = Tweet.preload(:replies).first
+        expect(tweet.replies.count).to eq(replies_count)
+      end
+    end
+
+    context "given belongs_to association" do
+      let!(:reply) { FactoryGirl.create(:reply, tweet: tweet) }
+
+      it "works as usual" do
+        preloaded_reply = Reply.preload(:tweet).find(reply.id)
+        expect(preloaded_reply.tweet).to eq(tweet)
+      end
+    end
+  end
+
+  describe "has_count association" do
+    let(:tweets_count) { 3 }
+    let(:tweets) do
+      tweets_count.times.map do
+        FactoryGirl.create(:tweet)
+      end
+    end
+
+    before do
+      tweets.each_with_index do |tweet, index|
+        index.times do
+          FactoryGirl.create(:reply, tweet: tweet)
+        end
+      end
+    end
+
+    it "does not execute N+1 queries by preload" do
+      expect_query_counts(1 + tweets_count) { Tweet.all.map(&:replies_count) }
+      expect_query_counts(2) { Tweet.all.preload(:replies_count).map(&:replies_count) }
+    end
+
+    it "counts properly" do
+      expected = Tweet.all.map { |t| t.replies.count }
+      expect(Tweet.all.map(&:replies_count)).to eq(expected)
+      expect(Tweet.all.preload(:replies_count).map(&:replies_count)).to eq(expected)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,39 @@
+require "pathname"
+require "pry"
+require "active_record"
+require "activerecord-has_count"
+
+spec_dir = Pathname.new(File.dirname(__FILE__))
+Dir[File.join(spec_dir, "models/*.rb")].each { |f| require f }
+
+require "factory_girl"
+Dir[File.join(spec_dir, "support/*.rb")].each { |f| require f }
+
+database_yml = File.join(spec_dir, "database.yml")
+ActiveRecord::Base.configurations["test"] = YAML.load_file(database_yml)["test"]
+ActiveRecord::Base.establish_connection :test
+
+ActiveRecord::Schema.define do
+  create_table :tweets, force: true do |t|
+    t.column :user_id, :integer
+    t.column :created_at, :datetime
+    t.column :updated_at, :datetime
+  end
+
+  create_table :replies, force: true do |t|
+    t.column :tweet_id, :integer
+    t.column :created_at, :datetime
+    t.column :updated_at, :datetime
+  end
+end
+
+RSpec.configure do |config|
+  ALL_MODELS = [
+    Tweet,
+    Reply,
+  ].freeze
+
+  config.after do
+    ALL_MODELS.each(&:delete_all)
+  end
+end

data/spec/support/assert_queries.rb

@@ -0,0 +1,54 @@
+# Copied from:
+# https://github.com/rails/rails/blob/9bb76261d39b59e7e229c80d052ca91a65ff17be/activerecord/test/cases/test_case.rb#L40-L52
+def expect_query_counts(num = 1, options = {})
+  ignore_none = options.fetch(:ignore_none) { num == :any }
+  SQLCounter.clear_log
+  x = yield
+
+  the_log = ignore_none ? SQLCounter.log_all : SQLCounter.log
+  expect(the_log.size).to eq(num)
+
+  x
+end
+
+class SQLCounter
+  class << self
+    attr_accessor :ignored_sql, :log, :log_all
+    def clear_log; self.log = []; self.log_all = []; end
+  end
+
+  self.clear_log
+
+  self.ignored_sql = [/^PRAGMA/, /^SELECT currval/, /^SELECT CAST/, /^SELECT @@IDENTITY/, /^SELECT @@ROWCOUNT/, /^SAVEPOINT/, /^ROLLBACK TO SAVEPOINT/, /^RELEASE SAVEPOINT/, /^SHOW max_identifier_length/, /^BEGIN/, /^COMMIT/]
+
+  # FIXME: this needs to be refactored so specific database can add their own
+  # ignored SQL, or better yet, use a different notification for the queries
+  # instead examining the SQL content.
+  oracle_ignored     = [/^select .*nextval/i, /^SAVEPOINT/, /^ROLLBACK TO/, /^\s*select .* from all_triggers/im, /^\s*select .* from all_constraints/im, /^\s*select .* from all_tab_cols/im]
+  mysql_ignored      = [/^SHOW TABLES/i, /^SHOW FULL FIELDS/, /^SHOW CREATE TABLE /i]
+  postgresql_ignored = [/^\s*select\b.*\bfrom\b.*pg_namespace\b/im, /^\s*select\b.*\battname\b.*\bfrom\b.*\bpg_attribute\b/im, /^SHOW search_path/i]
+  sqlite3_ignored =    [/^\s*SELECT name\b.*\bFROM sqlite_master/im]
+
+  [oracle_ignored, mysql_ignored, postgresql_ignored, sqlite3_ignored].each do |db_ignored_sql|
+    ignored_sql.concat db_ignored_sql
+  end
+
+  attr_reader :ignore
+
+  def initialize(ignore = Regexp.union(self.class.ignored_sql))
+    @ignore = ignore
+  end
+
+  def call(name, start, finish, message_id, values)
+    sql = values[:sql]
+
+    # FIXME: this seems bad. we should probably have a better way to indicate
+    # the query was cached
+    return if 'CACHE' == values[:name]
+
+    self.class.log_all << sql
+    self.class.log << sql unless ignore =~ sql
+  end
+end
+
+ActiveSupport::Notifications.subscribe('sql.active_record', SQLCounter.new)

data/spec/support/factories.rb

@@ -0,0 +1,4 @@
+FactoryGirl.define do
+  factory :tweet
+  factory :reply
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-has_count
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Takashi Kokubun
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-09-13 00:00:00.000000000 Z
+date: 2014-09-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - '>='
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: 3.2.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '>='
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: 3.2.0
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -116,18 +116,33 @@ extensions: []
 extra_rdoc_files: []
 files:
 - .gitignore
+- .rspec
+- .travis.yml
 - Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
 - activerecord-has_count.gemspec
+- benchmarks/Gemfile
+- benchmarks/README.md
+- benchmarks/benchmark.rb
 - lib/active_record/associations/builder/has_count.rb
 - lib/active_record/associations/has_count.rb
 - lib/active_record/associations/join_dependency/has_count.rb
 - lib/active_record/associations/preloader/has_count.rb
-- lib/active_record/has_count/version.rb
 - lib/active_record/reflection/has_count.rb
 - lib/activerecord-has_count.rb
+- lib/activerecord-has_count/model.rb
+- lib/activerecord-has_count/version.rb
+- spec/database.yml
+- spec/eager_load_spec.rb
+- spec/includes_spec.rb
+- spec/models/reply.rb
+- spec/models/tweet.rb
+- spec/preload_spec.rb
+- spec/spec_helper.rb
+- spec/support/assert_queries.rb
+- spec/support/factories.rb
 homepage: https://github.com/k0kubun/activerecord-has_count
 licenses:
 - MIT
@@ -148,9 +163,18 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.3
+rubygems_version: 2.0.14
 signing_key: 
 specification_version: 4
 summary: N+1 count query killer for ActiveRecord
-test_files: []
+test_files:
+- spec/database.yml
+- spec/eager_load_spec.rb
+- spec/includes_spec.rb
+- spec/models/reply.rb
+- spec/models/tweet.rb
+- spec/preload_spec.rb
+- spec/spec_helper.rb
+- spec/support/assert_queries.rb
+- spec/support/factories.rb
 has_rdoc: