activerecord-summarize 0.3.1 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d491ee7730156f77105ec7df6bac79b6410fa97b3387816f103dee233b43df8d
-  data.tar.gz: f33be41270ab955fcf2bf9b227cc7c212ae3aa385786da3a5b424a3e1e707e47
+  metadata.gz: 0e87406ae4f6c3aeec411824af98bb21b12457815f24e09f446ed8576bfc1352
+  data.tar.gz: 266e9065f9e49e458fa427d3a82c55eae82eafd983c27a5c8729125c2c75eb57
 SHA512:
-  metadata.gz: 0d1f5308da4fc8b781e8dd5a69a10c671106acdb9b565c056d23b33114fc96f8d4ff9a60f3887b861f9142b2564c3f33f17d9e8ea52c212c27abbdacc861e2d6
-  data.tar.gz: 318bad930ac53001068e6e3396d921f71ff62c8a0899abe7a96a55d9dab59aa7e6e45c2cdc6e7a5f5ae60b67f18a47be79cb73ee29a85e1fac25a988c43dc47a
+  metadata.gz: b515f889c18886602e6a695982ad755bdbb44b38ec93a1422cc92fb0ae9da612e3a7f2854d12c07864bedde52134f121823da201a8f52383564643ca2a7b8e84
+  data.tar.gz: e67437ac8503938c9f6f671fcf7c952aed1998efb045ff6a05a7d2a16e2c50ed7d79519f93b8a0d196cbf7d9d1bd9c23673e51487f7be8de3554cb27dde264fc

data/CHANGELOG.md

@@ -1,3 +1,15 @@
+## [0.4.0] - 2023-02-27
+
+- **FEATURE:** Support for top-level .group(:belongs_to_association), returning hash with models as keys.
+
+  I didn't realize this until a few months ago, but in ActiveRecord, if `Foo belongs_to :bar`, you can do `Foo.group(:bar).count` and get back a hash with `Bar` records as keys and counts as values. (ActiveRecord executes two total queries to implement this, one for the counts grouped by the `bar_id` foreign key, then another to retrieve the `Bar` models.)
+
+  Now the same behavior works with `summarize`: you can still retrieve any number of counts and/or sums about `Foo`—including some with additional filters and even sub-grouping—in a single query, and then we'll execute one additional query to retrieve the records for the `Bar` model keys.
+
+- **IMPROVEMENT:** `bin/console` is now much more useful for developing `activerecord-summarize`
+
+- **IMPROVEMENT:** Added some tests for queries joining HABTM associations and (of course, supporting the new feature) `belongs_to` associations. `summarize` preceded by joins is already stable and documented, but it didn't have tests before. 
+
 ## [0.3.1] - 2022-06-23
 
 - **BUGFIX:** `with` didn't work correctly with a single argument. Embarassingly, both the time-traveling version of `with` and the trivial/fake one provided when `noop: true` is set had single argument bugs, and they were different bugs.

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    activerecord-summarize (0.3.1)
+    activerecord-summarize (0.4.0)
       activerecord (>= 5.0)
 
 GEM

data/bin/console

@@ -2,10 +2,11 @@
 # frozen_string_literal: true
 
 require "bundler/setup"
+require "active_record"
 require "activerecord/summarize"
+require_relative "../test/test_data" # Test fixtures so there's something to play with
 
-# You can add fixtures and/or initialization code here to make experimenting
-# with your gem easier. You can also use a different console, if you like.
+# You can use a different console, if you like.
 
 # (If you use this, don't forget to add pry to your Gemfile!)
 # require "pry"

data/lib/activerecord/summarize/version.rb

@@ -2,6 +2,6 @@
 
 module ActiveRecord
   module Summarize
-    VERSION = "0.3.1"
+    VERSION = "0.4.0"
   end
 end

data/lib/activerecord/summarize.rb

@@ -7,7 +7,7 @@ module ActiveRecord::Summarize
   class Unsummarizable < StandardError; end
 
   class Summarize
-    attr_reader :current_result_row, :pure, :noop, :from_where
+    attr_reader :current_result_row, :base_groups, :base_association, :pure, :noop, :from_where
     alias_method :pure?, :pure
     alias_method :noop?, :noop
 
@@ -29,7 +29,18 @@ module ActiveRecord::Summarize
     def initialize(relation, pure: nil, noop: false)
       @relation = relation
       @noop = noop
-      has_base_groups = relation.group_values.any?
+      @base_groups, @base_association = relation.group_values.dup.then do |group_fields|
+        # Based upon a bit from ActiveRecord::Calculations.execute_grouped_calculation,
+        # if the base relation is grouped only by a belongs_to association, group by
+        # the association's foreign key.
+        if group_fields.size == 1 && group_fields.first.respond_to?(:to_sym)
+          association = relation.klass._reflect_on_association(group_fields.first)
+          # Like ActiveRecord's group(:association).count behavior, this only works with belongs_to associations
+          next [Array(association.foreign_key), association] if association&.belongs_to?
+        end
+        [group_fields, nil]
+      end
+      has_base_groups = base_groups.any?
       raise Unsummarizable, "`summarize` must be pure when called on a grouped relation" if pure == false && has_base_groups
       raise ArgumentError, "`summarize(noop: true)` is impossible on a grouped relation" if noop && has_base_groups
       @pure = has_base_groups || !!pure
@@ -53,24 +64,38 @@ module ActiveRecord::Summarize
       ))
       ChainableResult.with_cache(!pure?) do
         # `resolve` builds the single query that answers all collected calculations,
-        # executes it, and aggregates the results by the values of
-        # `@relation.group_values``. In the common case of no `@relation.group_values`,
-        # the result is just `{[]=>[*final_value_for_each_calculation]}`
+        # executes it, and aggregates the results by the values of `base_groups`.
+        # In the common case of no `base_groups`, the resolve returns:
+        # `{[]=>[*final_value_for_each_calculation]}`
         result = resolve.transform_values! do |row|
           # Each row (in the common case, only one) is used to resolve any
           # ChainableResults returned by the block. These may be a one-to-one mapping,
-          # or the block return may have combined some results via `with` or chained
+          # or the block return may have combined some results via `with`, chained
           # additional methods on results, etc..
           @current_result_row = row
           future_block_result.value
         end.then do |result|
-          # Change ungrouped result from `{[]=>v}` to `v` and grouped-by-one-column
-          # result from `{[k1]=>v1,[k2]=>v2,...}` to `{k1=>v1,k2=>v2,...}`.
-          # (Those are both probably more common than multiple-column base grouping.)
-          case @relation.group_values.size
-          when 0 then result.values.first
-          when 1 then result.transform_keys! { |k| k.first }
-          else result
+          # Now unpack/fix-up the result keys to match shape of Relation.count or Relation.group(*cols).count return values
+          if base_groups.empty?
+            # Change ungrouped result from `{[]=>v}` to `v`, like Relation.count
+            result.values.first
+          elsif base_association
+            # Change grouped-by-one-belongs_to-association result from `{[id1]=>v1,[id2]=>v2,...}` to
+            # `{<AssociatedModel id:id1>=>v1,<AssociatedModel id:id2>=>v2,...}` like Relation.group(:association).count
+
+            # Loosely based on a bit from ActiveRecord::Calculations.execute_grouped_calculation,
+            # retrieve the records for the group association and replace the keys of our final result.
+            key_class = base_association.klass.base_class
+            key_records = key_class
+              .where(key_class.primary_key => result.keys.flatten)
+              .index_by(&:id)
+            result.transform_keys! { |k| key_records[k[0]] }
+          elsif base_groups.size == 1
+            # Change grouped-by-one-column result from `{[k1]=>v1,[k2]=>v2,...}` to `{k1=>v1,k2=>v2,...}`, like Relation.group(:column).count
+            result.transform_keys! { |k| k[0] }
+          else
+            # Multiple-column base grouping (though perhaps relatively rare) requires no change.
+            result
           end
         end
         if !pure?
@@ -166,7 +191,7 @@ module ActiveRecord::Summarize
       base_group_columns = (0...base_groups.size)
       data
         .group_by { |row| row[base_group_columns] }
-        .tap { |h| h[[]] = [] if h.empty? && base_groups.size.zero? }
+        .tap { |h| h[[]] = [] if h.empty? && base_groups.empty? }
         .transform_values! do |rows|
           values = starting_values.map(&:dup) # map(&:dup) since some are hashes and we don't want to mutate starting_values
           rows.each do |row|
@@ -201,14 +226,10 @@ module ActiveRecord::Summarize
       end
     end
 
-    def base_groups
-      @relation.group_values.dup
-    end
-
     def all_groups
       # keep all base groups, even if they did something silly like group by
       # the same key twice, but otherwise don't repeat any groups
-      groups = base_groups
+      groups = base_groups.dup
       groups_set = Set.new(groups)
       @calculations.map { |f| f.relation.group_values }.flatten.each do |k|
         next if groups_set.include? k

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-summarize
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.4.0
 platform: ruby
 authors:
 - Joshua Paine
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-06-23 00:00:00.000000000 Z
+date: 2023-02-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord