eager_group 0.6.1 → 0.8.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 36652bc032832f5a84dc02733286cd156a3253b8c1ba3b1b9289fec7686745d7
-  data.tar.gz: da2a878d043e2a02abb5f64c6d1c679dd02fe02220ba6399f5312e1ee096f953
+  metadata.gz: 88912c5696afe9332d53ac15b2365d2e2d7112391672a2cba5db62012876a138
+  data.tar.gz: a18a2d21cd4299a68774f3dbb62556c71f3096b3ebac28bebf7a767a875fc00f
 SHA512:
-  metadata.gz: b7b4aacb136f425da49b81bf4d34c4bb467abc940b05fb936bd364b6884a322330acdec85449008de6f64716adc461ffebcad7a4b760f58fb44187b6abd2f3ba
-  data.tar.gz: 550d2eb69a366f90227c15382e25044078731610caae901982478baef95935dd581fc3b2a3affa04c48cab92a340d84744c18aeb5cb0a865a083ea78cee7bd69
+  metadata.gz: af269ea9b3be9f9a613f56cf14e52a7b183b6d041583f02aa88945f65150f98147ed7271523b9f8ec0d36c622f42ae257f7137e9cf842b381f11cbd7cd6e50bf
+  data.tar.gz: 2878aaefb0b9420b13531927cd46ad47894954c2999fe81d9bf853d7f2255ae97b42df8e56c43a840b5812d71ed1f535c391ccf605fbed99f08ed0769959eab8

data/CHANGELOG.md

@@ -1,5 +1,25 @@
 # Next Release
 
+## 0.8.1 (10/25/2019)
+
+* Fix for `has_many :through`
+
+## 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

data/README.md

@@ -8,29 +8,37 @@ flyerhzm/eager_group](https://awesomecode.io/projects/e5386790-9420-4003-831a-c9
 
 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,16 +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
 
+`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
 

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

@@ -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,36 +12,44 @@ 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
-          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)
-        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)
+        foreign_key, aggregate_hash =
+          if reflection.is_a?(ActiveRecord::Reflection::HasAndBelongsToManyReflection)
+            ["#{reflection.join_table}.#{reflection.foreign_key}", @klass.joins(reflection.name)]
+          elsif reflection.through_reflection
+            ["#{reflection.through_reflection.name}.#{reflection.through_reflection.foreign_key}", @klass.joins(reflection.name)]
+          else
+            [reflection.foreign_key, association_class]
+          end
+        aggregate_hash = aggregate_hash.where(foreign_key => record_ids)
+                                       .where(polymophic_as_condition(reflection))
+                                       .group(foreign_key)
+                                       .send(definition.aggregation_function, definition.column_name)
+        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.1'
+  VERSION = '0.8.1'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: eager_group
 version: !ruby/object:Gem::Version
-  version: 0.6.1
+  version: 0.8.1
 platform: ruby
 authors:
 - Richard Huang
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-03-05 00:00:00.000000000 Z
+date: 2019-10-25 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,8 +142,6 @@ 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
@@ -152,7 +164,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.1
+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