eager_group 0.6.0 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 22abe02d6bafe11c49460a72d251e3686f007796
-  data.tar.gz: c4df75c16f76a672fc4b6dcfea0f5fe80399c064
+SHA256:
+  metadata.gz: 516b00c6397d1a6b397b165687091079118a48ed39fc0afce4542d3cf4f7f481
+  data.tar.gz: 9bf3083695c819003574f3971d2a592443320af92dc98c1ff36b302c87718889
 SHA512:
-  metadata.gz: 33cd73103c6cb2597a13e640b028b7c2bfc75982ed3746355b07b758cb3810f5923fdb7967a4e102591d0aa07b51453d0473be94c2d5b2036f123e9286395ddd
-  data.tar.gz: 61e0c3121f8504b094e11807a0f377f16c406b26973feea5a631152d0437465131720c0586870cee4e54e5f748bc01f976d3c4da78562ff741e6575a0b663002
+  metadata.gz: 389265b557184c2d3f3c0207340c8bd65086a38fb8e0b2b168a4c14ed37f82b5bcb0ee89ab7a48da528bfbcf2174c1c89dcc0fd917eade1de9c184cad3238e9b
+  data.tar.gz: 6e5e9bd946a9d333bda2087578ac47b98d57ab0cb8347adc9577f582124e1ca9a571fdddeaa28da48644aca0f9d0546f1ee323149742b2c0868d5d6c324354da

data/CHANGELOG.md

@@ -1,5 +1,25 @@
 # Next Release
 
+## 0.8.0 (10/21/2019)
+
+* Support `has_and_belongs_to_many`
+
+## 0.7.2 (10/10/2019)
+
+* Simplify `association_klass` for `first_object` and `last_object`
+
+## 0.7.1 (08/23/2019)
+
+* Set `eager_group_definitions` by `mattr_accessor`
+
+## 0.7.0 (08/22/2019)
+
+* Add `first_object` and `last_object` aggregation
+
+## 0.6.1 (03/05/2018)
+
+* Skip preload when association is empty
+
 ## 0.6.0 (12/15/2018)
 
 * Support hash as `eager_group` argument

data/README.md

@@ -1,36 +1,44 @@
 # EagerGroup
 
-[![Build Status](https://secure.travis-ci.org/xinminlabs/eager_group.png)](http://travis-ci.org/xinminlabs/eager_group)
+[![Build Status](https://secure.travis-ci.org/flyerhzm/eager_group.png)](http://travis-ci.org/flyerhzm/eager_group)
 [![AwesomeCode Status for
-xinminlabs/eager_group](https://awesomecode.io/projects/e5386790-9420-4003-831a-c9a8c8a48108/status)](https://awesomecode.io/repos/xinminlabs/eager_group)
+flyerhzm/eager_group](https://awesomecode.io/projects/e5386790-9420-4003-831a-c9a8c8a48108/status)](https://awesomecode.io/repos/flyerhzm/eager_group)
 
-[More explaination on our blog](http://blog.xinminlabs.com/2015/06/29/eager_group/)
+[More explaination on our blog](http://blog.flyerhzm.com/2015/06/29/eager_group/)
 
 Fix n+1 aggregate sql functions for rails, like
 
-    SELECT "posts".* FROM "posts";
-    SELECT COUNT(*) FROM "comments" WHERE "comments"."post_id" = 1 AND "comments"."status" = 'approved'
-    SELECT COUNT(*) FROM "comments" WHERE "comments"."post_id" = 2 AND "comments"."status" = 'approved'
-    SELECT COUNT(*) FROM "comments" WHERE "comments"."post_id" = 3 AND "comments"."status" = 'approved'
+```
+SELECT "posts".* FROM "posts";
+SELECT COUNT(*) FROM "comments" WHERE "comments"."post_id" = 1 AND "comments"."status" = 'approved'
+SELECT COUNT(*) FROM "comments" WHERE "comments"."post_id" = 2 AND "comments"."status" = 'approved'
+SELECT COUNT(*) FROM "comments" WHERE "comments"."post_id" = 3 AND "comments"."status" = 'approved'
+```
 
 =>
 
-    SELECT "posts".* FROM "posts";
-    SELECT COUNT(*) AS count_all, post_id AS post_id FROM "comments" WHERE "comments"."post_id" IN (1, 2, 3) AND "comments"."status" = 'approved' GROUP BY post_id;
+```
+SELECT "posts".* FROM "posts";
+SELECT COUNT(*) AS count_all, post_id AS post_id FROM "comments" WHERE "comments"."post_id" IN (1, 2, 3) AND "comments"."status" = 'approved' GROUP BY post_id;
+```
 
 or
 
-    SELECT "posts".* FROM "posts";
-    SELECT AVG("comments"."rating") AS avg_id FROM "comments" WHERE "comments"."post_id" = 1;
-    SELECT AVG("comments"."rating") AS avg_id FROM "comments" WHERE "comments"."post_id" = 2;
-    SELECT AVG("comments"."rating") AS avg_id FROM "comments" WHERE "comments"."post_id" = 3;
+```
+SELECT "posts".* FROM "posts";
+SELECT AVG("comments"."rating") AS avg_id FROM "comments" WHERE "comments"."post_id" = 1;
+SELECT AVG("comments"."rating") AS avg_id FROM "comments" WHERE "comments"."post_id" = 2;
+SELECT AVG("comments"."rating") AS avg_id FROM "comments" WHERE "comments"."post_id" = 3;
+```
 
 =>
 
-    SELECT "posts".* FROM "posts";
-    SELECT AVG("comments"."rating") AS average_comments_rating, post_id AS post_id FROM "comments" WHERE "comments"."post_id" IN (1, 2, 3) GROUP BY post_id;
+```
+SELECT "posts".* FROM "posts";
+SELECT AVG("comments"."rating") AS average_comments_rating, post_id AS post_id FROM "comments" WHERE "comments"."post_id" IN (1, 2, 3) GROUP BY post_id;
+```
 
-It supports Rails 4.x and Rails 5.x
+It supports Rails 4.x, Rails 5.x and Rails 6.x
 
 ## Installation
 
@@ -42,29 +50,35 @@ gem 'eager_group'
 
 And then execute:
 
-    $ bundle
+```
+$ bundle
+```
 
 Or install it yourself as:
 
-    $ gem install eager_group
+```
+$ gem install eager_group
+```
 
 ## Usage
 
 First you need to define what aggregate function you want to eager
 load.
 
-    class Post < ActiveRecord::Base
-      has_many :comments
+```ruby
+class Post < ActiveRecord::Base
+  has_many :comments
 
-      define_eager_group :comments_average_rating, :comments, :average, :rating
-      define_eager_group :approved_comments_count, :comments, :count, :*, -> { approved }
-    end
+  define_eager_group :comments_average_rating, :comments, :average, :rating
+  define_eager_group :approved_comments_count, :comments, :count, :*, -> { approved }
+end
 
-    class Comment < ActiveRecord::Base
-      belongs_to :post
+class Comment < ActiveRecord::Base
+  belongs_to :post
 
-      scope :approved, -> { where(status: 'approved') }
-    end
+  scope :approved, -> { where(status: 'approved') }
+end
+```
 
 The parameters for `define_eager_group` are as follows
 
@@ -73,18 +87,22 @@ method, it also generates a method with the same name to fetch the
 result.
 * `association`, association name you want to aggregate.
 * `aggregate_function`, aggregate sql function, can be one of `average`,
-`count`, `maximum`, `minimum`, `sum`.
+`count`, `maximum`, `minimum`, `sum`, I define 2 additional aggregate
+function `first_object` and `last_object` to eager load first and last
+association objects.
 * `column_name`, aggregate column name, it can be `:*` for `count`
 * `scope`, scope is optional, it's used to filter data for aggregation.
 
 Then you can use `eager_group` to fix n+1 aggregate sql functions
 when querying
 
-    posts = Post.all.eager_group(:comments_average_rating, :approved_comments_count)
-    posts.each do |post|
-      post.comments_average_rating
-      post.approved_comments_count
-    end
+```ruby
+posts = Post.all.eager_group(:comments_average_rating, :approved_comments_count)
+posts.each do |post|
+  post.comments_average_rating
+  post.approved_comments_count
+end
+```
 
 EagerGroup will execute `GROUP BY` sqls for you then set the value of
 attributes.
@@ -93,13 +111,51 @@ attributes.
 You can call the `definition_name` directly for convenience,
 but it would not help you to fix n+1 aggregate sql issue.
 
-    post = Post.first
-    post.commets_average_rating
-    post.approved_comments_count
+```
+post = Post.first
+post.commets_average_rating
+post.approved_comments_count
+```
 
 ## Advanced
 
-   User.limit(10).includes(:posts).eager_group(posts: [:comments_average_rating, :approved_comments_count])
+`eager_group` through association
+
+```ruby
+User.limit(10).includes(:posts).eager_group(posts: [:comments_average_rating, :approved_comments_count])
+```
+
+pass parameter to scope
+
+```ruby
+class Post < ActiveRecord::Base
+  has_many :comments
+
+  define_eager_group :comments_average_rating_by_author, :comments, :average, :rating, ->(author, ignore) { by_author(author, ignore) }
+end
+
+posts = Post.all.eager_group([:comments_average_rating_by_author, author, true])
+posts.each { |post| post.comments_average_rating_by_author }
+```
+
+`first_object` and `last_object` aggregation to eager load first and
+last association objects.
+
+```ruby
+class Post < ActiveRecord::Base
+  has_many :comments
+
+  define_eager_group :first_comment, :comments, :first_object, :id
+  define_eager_group :last_comment, :comments, :last_object, :id
+end
+
+posts = Post.all.eager_group(:first_comment, :last_comment)
+posts.each do |post|
+  post.first_comment
+  post.last_comment
+end
+```
+
 
 ## Benchmark
 
@@ -109,6 +165,6 @@ times faster, WOW!
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/xinminlabs/eager_group.
+Bug reports and pull requests are welcome on GitHub at https://github.com/flyerhzm/eager_group.
 
-[1]:  https://github.com/xinminlabs/eager_group/blob/master/benchmark.rb
+[1]:  https://github.com/flyerhzm/eager_group/blob/master/benchmark.rb

data/benchmark.rb

@@ -30,11 +30,11 @@ class Comment < ActiveRecord::Base
 end
 
 # create database eager_group_benchmark;
-ActiveRecord::Base.establish_connection(adapter: 'mysql2', database: 'eager_group_benchmark', server: '/tmp/mysql.socket', username: 'root')
+ActiveRecord::Base.establish_connection(
+  adapter: 'mysql2', database: 'eager_group_benchmark', server: '/tmp/mysql.socket', username: 'root'
+)
 
-ActiveRecord::Base.connection.tables.each do |table|
-  ActiveRecord::Base.connection.drop_table(table)
-end
+ActiveRecord::Base.connection.tables.each { |table| ActiveRecord::Base.connection.drop_table(table) }
 
 ActiveRecord::Schema.define do
   self.verbose = false
@@ -55,18 +55,19 @@ ActiveRecord::Schema.define do
 end
 
 posts_size = 100
-comments_size = 1000
+comments_size = 1_000
 
 posts = []
-posts_size.times do |i|
-  posts << Post.new(title: "Title #{i}", body: "Body #{i}")
-end
+posts_size.times { |i| posts << Post.new(title: "Title #{i}", body: "Body #{i}") }
 Post.import posts
 post_ids = Post.all.pluck(:id)
 
 comments = []
 comments_size.times do |i|
-  comments << Comment.new(body: "Comment #{i}", post_id: post_ids[i % 100], status: %w[approved deleted][i % 2], rating: i % 5 + 1)
+  comments <<
+    Comment.new(
+      body: "Comment #{i}", post_id: post_ids[i % 100], status: %w[approved deleted][i % 2], rating: i % 5 + 1
+    )
 end
 Comment.import comments
 

data/eager_group.gemspec

@@ -12,7 +12,7 @@ Gem::Specification.new do |spec|
 
   spec.summary       = 'Fix n+1 aggregate sql functions'
   spec.description   = 'Fix n+1 aggregate sql functions for rails'
-  spec.homepage      = 'https://github.com/xinminlabs/eager_group'
+  spec.homepage      = 'https://github.com/flyerhzm/eager_group'
 
   spec.license = 'MIT'
 
@@ -23,9 +23,10 @@ Gem::Specification.new do |spec|
 
   spec.add_development_dependency 'activerecord'
   spec.add_development_dependency 'activerecord-import'
+  spec.add_development_dependency 'activesupport'
   spec.add_development_dependency 'benchmark-ips'
   spec.add_development_dependency 'bundler'
   spec.add_development_dependency 'rake', '~> 10.0'
   spec.add_development_dependency 'rspec', '~> 3.3'
-  spec.add_development_dependency 'sqlite3', '~> 1.3'
+  spec.add_development_dependency 'sqlite3'
 end

data/lib/eager_group.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'active_support/core_ext/module/attribute_accessors'
 require 'eager_group/version'
 
 module EagerGroup
@@ -11,7 +12,7 @@ module EagerGroup
   end
 
   module ClassMethods
-    attr_reader :eager_group_definitions
+    mattr_accessor :eager_group_definitions, default: {}
 
     # class Post
     #   define_eager_group :comments_avergage_rating, :comments, :average, :rating
@@ -19,16 +20,16 @@ module EagerGroup
     # end
     def define_eager_group(attr, association, aggregate_function, column_name, scope = nil)
       send :attr_accessor, attr
-      @eager_group_definitions ||= {}
-      @eager_group_definitions[attr] = Definition.new association, aggregate_function, column_name, scope
+      eager_group_definitions[attr] = Definition.new(association, aggregate_function, column_name, scope)
 
-      define_method attr, lambda { |*args|
-        query_result_cache = instance_variable_get("@#{attr}")
-        return query_result_cache if args.blank? && query_result_cache.present?
+      define_method attr,
+                    lambda { |*args|
+                      query_result_cache = instance_variable_get("@#{attr}")
+                      return query_result_cache if args.blank? && query_result_cache.present?
 
-        preload_eager_group(attr, *args)
-        instance_variable_get("@#{attr}")
-      }
+                      preload_eager_group(attr, *args)
+                      instance_variable_get("@#{attr}")
+                    }
 
       define_method "#{attr}=" do |val|
         instance_variable_set("@#{attr}", val)
@@ -51,4 +52,4 @@ ActiveRecord::Base.class_eval do
   end
 end
 require 'active_record/with_eager_group'
-ActiveRecord::Relation.send :prepend, ActiveRecord::WithEagerGroup
+ActiveRecord::Relation.prepend ActiveRecord::WithEagerGroup

data/lib/eager_group/definition.rb

@@ -2,7 +2,7 @@
 
 module EagerGroup
   class Definition
-    attr_reader :association, :aggregate_function, :column_name, :scope
+    attr_reader :association, :column_name, :scope
 
     def initialize(association, aggregate_function, column_name, scope)
       @association = association
@@ -10,5 +10,20 @@ module EagerGroup
       @column_name = column_name
       @scope = scope
     end
+
+    def aggregation_function
+      return :maximum if @aggregate_function.to_sym == :last_object
+      return :minimum if @aggregate_function.to_sym == :first_object
+
+      @aggregate_function
+    end
+
+    def need_load_object
+      %i[first_object last_object].include?(@aggregate_function.to_sym)
+    end
+
+    def default_value
+      %i[first_object last_object].include?(@aggregate_function.to_sym) ? nil : 0
+    end
   end
 end

data/lib/eager_group/preloader.rb

@@ -12,35 +12,54 @@ module EagerGroup
     def run
       primary_key = @klass.primary_key
       @eager_group_values.each do |eager_group_value|
-        definition_key, arguments = eager_group_value.is_a?(Array) ? [eager_group_value.shift, eager_group_value] : [eager_group_value, nil]
+        definition_key, arguments =
+          eager_group_value.is_a?(Array) ? [eager_group_value.shift, eager_group_value] : [eager_group_value, nil]
+
         if definition_key.is_a?(Hash)
           association_name, definition_key = *definition_key.first
           @records = @records.flat_map { |record| record.send(association_name) }
+          next if @records.empty?
+
           @klass = @records.first.class
         end
         record_ids = @records.map { |record| record.send(primary_key) }
-        next unless definition = @klass.eager_group_definitions[definition_key]
+        unless definition = @klass.eager_group_definitions[definition_key]
+          next
+        end
 
         reflection = @klass.reflect_on_association(definition.association)
         association_class = reflection.klass
         association_class = association_class.instance_exec(*arguments, &definition.scope) if definition.scope
 
-        if reflection.through_reflection
+        if reflection.is_a?(ActiveRecord::Reflection::HasAndBelongsToManyReflection)
+          foreign_key = "#{reflection.join_table}.#{reflection.foreign_key}"
+          aggregate_hash =
+            @klass.joins(reflection.name).where(foreign_key => record_ids).where(
+              polymophic_as_condition(reflection)
+            )
+              .group(foreign_key)
+              .send(definition.aggregation_function, definition.column_name)
+        elsif reflection.through_reflection
           foreign_key = "#{reflection.through_reflection.name}.#{reflection.through_reflection.foreign_key}"
-          aggregate_hash = association_class.joins(reflection.through_reflection.name)
-                                            .where(foreign_key => record_ids)
-                                            .where(polymophic_as_condition(reflection.through_reflection))
-                                            .group(foreign_key)
-                                            .send(definition.aggregate_function, definition.column_name)
+          aggregate_hash =
+            association_class.joins(reflection.through_reflection.name).where(foreign_key => record_ids).where(
+              polymophic_as_condition(reflection.through_reflection)
+            )
+              .group(foreign_key)
+              .send(definition.aggregation_function, definition.column_name)
         else
-          aggregate_hash = association_class.where(reflection.foreign_key => record_ids)
-                                            .where(polymophic_as_condition(reflection))
-                                            .group(reflection.foreign_key)
-                                            .send(definition.aggregate_function, definition.column_name)
+          aggregate_hash =
+            association_class.where(reflection.foreign_key => record_ids).where(polymophic_as_condition(reflection))
+              .group(reflection.foreign_key)
+              .send(definition.aggregation_function, definition.column_name)
+        end
+        if definition.need_load_object
+          aggregate_objects = reflection.klass.find(aggregate_hash.values).each_with_object({}) { |o, h| h[o.id] = o }
+          aggregate_hash.keys.each { |key| aggregate_hash[key] = aggregate_objects[aggregate_hash[key]] }
         end
         @records.each do |record|
           id = record.send(primary_key)
-          record.send("#{definition_key}=", aggregate_hash[id] || 0)
+          record.send("#{definition_key}=", aggregate_hash[id] || definition.default_value)
         end
       end
     end

data/lib/eager_group/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module EagerGroup
-  VERSION = '0.6.0'
+  VERSION = '0.8.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: eager_group
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.8.0
 platform: ruby
 authors:
 - Richard Huang
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-12-15 00:00:00.000000000 Z
+date: 2019-10-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -38,6 +38,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: benchmark-ips
   requirement: !ruby/object:Gem::Requirement
@@ -98,16 +112,16 @@ dependencies:
   name: sqlite3
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.3'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.3'
+        version: '0'
 description: Fix n+1 aggregate sql functions for rails
 email:
 - flyerhzm@gmail.com
@@ -128,12 +142,10 @@ files:
 - eager_group.gemspec
 - lib/active_record/with_eager_group.rb
 - lib/eager_group.rb
-- lib/eager_group/active_record_base.rb
-- lib/eager_group/active_record_relation.rb
 - lib/eager_group/definition.rb
 - lib/eager_group/preloader.rb
 - lib/eager_group/version.rb
-homepage: https://github.com/xinminlabs/eager_group
+homepage: https://github.com/flyerhzm/eager_group
 licenses:
 - MIT
 metadata: {}
@@ -152,8 +164,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.14
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: Fix n+1 aggregate sql functions

data/lib/eager_group/active_record_base.rb

@@ -1,8 +0,0 @@
-# frozen_string_literal: true
-
-class ActiveRecord::Base
-  class <<self
-    # Post.eager_group(:approved_comments_count, :comments_average_rating)
-    delegate :eager_group, to: :all
-  end
-end

data/lib/eager_group/active_record_relation.rb

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-
-class ActiveRecord::Relation
-  # Post.all.eager_group(:approved_comments_count, :comments_average_rating)
-
-  def exec_queries_with_eager_group
-    records = exec_queries_without_eager_group
-    EagerGroup::Preloader.new(klass, records, eager_group_values).run if eager_group_values.present?
-    records
-  end
-  alias_method_chain :exec_queries, :eager_group
-
-  def eager_group(*args)
-    check_if_method_has_arguments!('eager_group', args)
-    spawn.eager_group!(*args)
-  end
-
-  def eager_group!(*args)
-    self.eager_group_values += args
-    self
-  end
-
-  def eager_group_values
-    @values[:eager_group] || []
-  end
-
-  def eager_group_values=(values)
-    raise ImmutableRelation if @loaded
-
-    @values[:eager_group] = values
-  end
-end