preload_counts 0.0.2

data/.gitignore

@@ -0,0 +1,7 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+tags
+*.swp
+*.swo

data/.rvmrc

@@ -0,0 +1 @@
+rvm use ree-1.8.7@preload_counts

data/Gemfile

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

data/README.rdoc

@@ -0,0 +1,82 @@
+= Preload Counts
+
+Did you ever write an index page that only needs the count of an association? Consider the following example: 
+
+  # Models
+  class Post < ActiveRecord::Base
+    has_many :comments
+  end
+  
+  class Comment < ActiveRecord::Base
+    belongs_to :post
+  
+    named_scope :by_moderators, lambda { {:conditions => {:by_moderator => true} }
+  end
+
+  # Controller
+  def index
+    @posts = Post.all
+  end
+
+  # View
+  <% @posts.each do |post| %>
+    <%= post.name %>
+    (<%= post.comments.count %>)
+    (<%= post.comments.by_moderators.count %>)
+  <% end %>
+
+
+This will create two count request to the database for each post each time the view 
+is rendered. This is really slow. Preload counts helps you minimize the number of 
+calls to the database with minimal code change. 
+
+== Usage
+
+  # Model
+  class Post < ActiveRecord::Base
+    # create a named_scope to preload the comments count as well as the comments
+    # by_moderators. 
+    preload_counts :comments => [:by_moderators]
+
+    # preload_counts :comments would have only, preloaded the comments which
+    # would have been slightly faster. You can preload any number of scopes, but
+    # the more to preload, the more complex and slow the request will be.
+    has_many :comments
+  end
+
+  # Controller
+  def index
+    # Tell AR to preload the counts in the select request. If you don't specify
+    # this, the behaviour is to fallback to the slow count.
+    @posts = Post.preload_comment_counts
+  end
+
+  # View
+  # You have different accessor to get to the count. Beware of methods like
+  # .empty? that has an internal call to count.
+  <% @posts.each do |post| %>
+    <%= post.name %>
+    (<%= post.comments_count %>)
+    (<%= post.by_moderators_comments_count %>)
+  <% end %>
+
+== Benchmark
+
+More in depth benchmarking is needed, but here's sone annecdotal evidence.
+
+Without: 650ms per request
+With: 450ms per request
+
+That's right, this saved me 200ms per request with very minimal code change. 
+
+== Support
+
+This has been tested on Rails 2.3.12 and Rails 3.1.0
+
+== Help
+
+- My request is still slow? 
+
+It's possible that this isn't the fix you need. Sometime multiple small requests might be faster than one large request. Always benchmark your page before using this gem. 
+
+Another think you might want to look into is adding index to speedup the query that is being generated by preload_counts. 

data/Rakefile

@@ -0,0 +1,24 @@
+require "bundler/gem_tasks"
+require "load_multi_rails_rake_tasks"
+
+require 'rspec/core/rake_task'
+
+desc 'Default: run specs.'
+task :default => :spec
+
+desc "Run specs"
+RSpec::Core::RakeTask.new do |t|
+  t.pattern = "./spec/**/*_spec.rb" # don't need this, it's default.
+  # Put spec opts in a file named .rspec in root
+end
+
+desc "Generate code coverage"
+RSpec::Core::RakeTask.new(:coverage) do |t|
+  t.pattern = "./spec/**/*_spec.rb" # don't need this, it's default.
+  t.rcov = true
+  t.rcov_opts = ['--exclude', 'spec']
+end
+
+desc 'All tests'
+task :test => :spec do
+end

data/lib/preload_counts/ar.rb

@@ -0,0 +1,103 @@
+# This adds a scope to preload the counts of an association in one SQL query. 
+#
+# Consider the following code:
+# Service.all.each{|s| puts s.incidents.acknowledged.count}
+#
+# Each time count is called, a db query is made to fetch the count. 
+#
+# Adding this to the Service class:
+#
+# preload_counts :incidents => [:acknowledged]
+#
+# will add a preload_incident_counts scope to preload the counts and add
+# accessors to the class. So our codes becaumes
+#
+# Service.preload_incident_counts.all.each{|s| puts s.acknowledged_incidents_count}
+#
+# And only requires one DB query.
+module PreloadCounts
+  module ClassMethods
+    def preload_counts(options)
+      options = Array(options).inject({}) {|h, v| h[v] = []; h}  unless options.is_a?(Hash)
+      options.each do |association, scopes|
+        scopes = scopes + [nil]
+
+        # Define singleton metho to load all counts
+        name = "preload_#{association.to_s.singularize}_counts"
+        singleton = class << self; self end
+        singleton.send :define_method, name do
+          sql = ['*'] + scopes_to_select(association, scopes)
+          sql = sql.join(', ')
+          scoped(:select => sql)
+        end
+
+        scopes.each do |scope|
+          # Define accessor for each count
+          accessor_name = find_accessor_name(association, scope)
+          define_method accessor_name do
+            result = send(association)
+            result = result.send(scope) if scope
+            (self[accessor_name] || result.size).to_i
+          end
+        end
+
+      end
+    end
+    
+    private
+    def scopes_to_select(association, scopes)
+      scopes.map do |scope|
+        scope_to_select(association, scope)
+      end
+    end
+
+    def scope_to_select(association, scope)
+      resolved_association = association.to_s.singularize.camelize.constantize
+      conditions = []
+
+      if scope
+        if ActiveRecord::VERSION::MAJOR < 3
+          scope_sql = resolved_association.scopes[scope].call(resolved_association).send(:construct_finder_sql, {})
+        else
+          scope_sql = resolved_association.send(scope).to_sql
+        end
+        condition = scope_sql.gsub(/^.*WHERE/, '')
+        conditions << condition
+      end
+
+      association_condition = self.reflections[association].options[:conditions]
+      conditions << association_condition if association_condition
+
+      # FIXME This is a really hacking way of getting the named_scope condition.
+      # In Rails 3 we would have AREL to get to it. 
+      sql = <<-SQL
+      (SELECT count(*) 
+       FROM #{association} 
+       WHERE #{association}.#{table_name.singularize}_id = #{table_name}.id AND 
+       #{conditions_to_sql conditions}) as #{find_accessor_name(association, scope)} 
+      SQL
+    end
+
+    def find_accessor_name(association, scope)
+      accessor_name = "#{association}_count"
+      accessor_name = "#{scope}_" + accessor_name if scope
+      accessor_name
+    end
+
+    def conditions_to_sql(conditions)
+      conditions = ["1 = 1"] if conditions.empty?
+      conditions.join(" AND ")
+    end
+  end
+
+  module InstanceMethods
+  end
+
+  def self.included(receiver)
+    receiver.extend ClassMethods
+    receiver.send :include, InstanceMethods
+  end
+end
+
+ActiveRecord::Base.class_eval { include PreloadCounts }
+

data/lib/preload_counts/version.rb

@@ -0,0 +1,3 @@
+module PreloadCounts
+  VERSION = "0.0.2"
+end

data/lib/preload_counts.rb

@@ -0,0 +1,3 @@
+require "preload_counts/version"
+require "preload_counts/ar"
+

data/preload_counts.gemspec

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "preload_counts/version"
+
+Gem::Specification.new do |s|
+  s.name        = "preload_counts"
+  s.version     = PreloadCounts::VERSION
+  s.authors     = ["Simon Mathieu"]
+  s.email       = ["simon.math@gmail.com"]
+  s.homepage    = "https://github.com/smathieu/preload_counts"
+  s.summary     = %q{Preload association or scope counts.}
+  s.description = %q{Preload association or scope counts. This can greatly reduce the number of queries you have to perform and thus yield great performance gains.}
+
+  s.rubyforge_project = "preload_counts"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_development_dependency "rspec"
+  s.add_development_dependency "activerecord", "~> 3.2.0"
+  s.add_development_dependency "sqlite3"
+  s.add_development_dependency "ruby-debug"
+  s.add_development_dependency "multi_rails"
+end

data/spec/active_record_spec.rb

@@ -0,0 +1,99 @@
+require 'spec_helper'
+require 'logger'
+
+if ActiveRecord::VERSION::MAJOR < 3
+  ActiveRecord::Base.establish_connection(:adapter => "sqlite3", :dbfile => ":memory:")
+else
+  ActiveRecord::Base.establish_connection(:adapter => "sqlite3", :database => ":memory:")
+  ActiveRecord::Base.logger = Logger.new(nil)
+end
+
+def setup_db
+  ActiveRecord::Schema.define(:version => 1) do
+    create_table :posts do |t|
+    end
+
+    create_table :comments do |t|
+      t.integer :post_id, :null => false 
+      t.datetime :deleted_at
+    end
+  end
+end
+
+setup_db 
+
+class Post < ActiveRecord::Base
+  has_many :comments
+  has_many :active_comments, :conditions => "deleted_at IS NULL", :class_name => 'Comment'
+  preload_counts :comments => [:with_even_id]
+  preload_counts :active_comments
+end
+
+class PostWithActiveComments < ActiveRecord::Base
+  set_table_name :posts
+
+  has_many :comments, :conditions => "deleted_at IS NULL"
+  preload_counts :comments
+end
+
+class Comment < ActiveRecord::Base
+  belongs_to :post
+
+  if ActiveRecord::VERSION::MAJOR < 3
+    named_scope :with_even_id, lambda { {:conditions => "comments.id % 2 == 0"} }
+  else
+    scope :with_even_id, where('id % 2 = 0')
+  end
+end
+
+def create_data
+  post = Post.create 
+  5.times { post.comments.create }
+  5.times { post.comments.create :deleted_at => Time.now }
+end
+
+create_data
+
+describe Post do
+  it "should have a preload_comment_counts scope" do
+    Post.should respond_to(:preload_comment_counts) 
+  end
+
+  describe 'instance' do
+    let(:post) { Post.first } 
+
+    it "should have a comment_count accessor" do
+      post.should respond_to(:comments_count) 
+    end
+
+    it "should be able to get count without preloading them" do
+      post.comments_count.should equal(10)
+    end
+
+    it "should have an active_comments_count accessor" do
+      post.should respond_to(:comments_count) 
+    end
+  end
+
+  describe 'instance with preloaded count' do
+    let(:post) { Post.preload_comment_counts.first } 
+
+    it "should be able to get the association count" do
+      post.comments_count.should equal(10)
+    end
+
+    it "should be able to get the association count with a scope" do
+      post.with_even_id_comments_count.should equal(5)
+    end
+  end
+end
+
+describe PostWithActiveComments do
+  describe 'instance with preloaded count' do
+    let(:post) { PostWithActiveComments.preload_comment_counts.first } 
+
+    it "should be able to get the association count" do
+      post.comments_count.should equal(5)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,9 @@
+require 'rspec'
+require 'active_record'
+require 'preload_counts'
+
+RSpec.configure do |config|
+  config.color_enabled = true
+  config.formatter     = 'documentation'
+end
+

metadata

@@ -0,0 +1,148 @@
+--- !ruby/object:Gem::Specification 
+name: preload_counts
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 2
+  version: 0.0.2
+platform: ruby
+authors: 
+- Simon Mathieu
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-08-01 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  version_requirements: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  requirement: *id001
+  prerelease: false
+- !ruby/object:Gem::Dependency 
+  name: activerecord
+  version_requirements: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 15
+        segments: 
+        - 3
+        - 2
+        - 0
+        version: 3.2.0
+  type: :development
+  requirement: *id002
+  prerelease: false
+- !ruby/object:Gem::Dependency 
+  name: sqlite3
+  version_requirements: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  requirement: *id003
+  prerelease: false
+- !ruby/object:Gem::Dependency 
+  name: ruby-debug
+  version_requirements: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  requirement: *id004
+  prerelease: false
+- !ruby/object:Gem::Dependency 
+  name: multi_rails
+  version_requirements: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  requirement: *id005
+  prerelease: false
+description: Preload association or scope counts. This can greatly reduce the number of queries you have to perform and thus yield great performance gains.
+email: 
+- simon.math@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- .rvmrc
+- Gemfile
+- README.rdoc
+- Rakefile
+- lib/preload_counts.rb
+- lib/preload_counts/ar.rb
+- lib/preload_counts/version.rb
+- preload_counts.gemspec
+- spec/active_record_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/smathieu/preload_counts
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: preload_counts
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Preload association or scope counts.
+test_files: 
+- spec/active_record_spec.rb
+- spec/spec_helper.rb