counter_culture 3.5.0 → 3.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: acebc4b3981511ea35497a3f276372253cb709314002ab2c6c498fb9b60a0166
-  data.tar.gz: b659b8956b8e6911c58563e4f921487f49a3ddf8ada5fbee7b79b0de16f8796d
+  metadata.gz: 225d25bff8cd9226371b162e6761603271cbac02c74be1dd7398de2dc63dbb71
+  data.tar.gz: ea2b215508e285bab75efcbf3aeb153a15458c22db0cc0b79350bb2e9b3a9e05
 SHA512:
-  metadata.gz: 9ef804972ebbd99b5945b22d87c85d93dcd3af1ea78f04683a0799b67d25d42cb8c4ca52e08b9267fbd17f11e6fcd07a334e5990cccd5e4fd3ea27991da67fb4
-  data.tar.gz: 81fa1adc6e283a1fed1a661e08cc7bd4a5280062cb8567ef730ce59342b0cf49032d09a9fc05bcbff713fbbd37d9a7157f2de35bc25df696d48f5de5bed9281c
+  metadata.gz: 5362e9b1db5c4a81944e3deeddec9c7945ae349cca9f663dae140fb1516f00b9bd41d4d34af4705c2d4600ee65dabe2a41bc0a53e1a98ba682385228b0f4e41a
+  data.tar.gz: 60d99dab523e3f339961c4d19393f27de41006c361dc190baf25676157dded5b98382d77cca3dd76533cb070e3eec14965bb90ffe3f13991ba6d409cdf3e779a

data/.circleci/config.yml

@@ -48,8 +48,8 @@ workflows:
       - test:
           matrix:
             parameters:
-              ruby-version: ["2.6", "2.7", "3.0", "3.1", "3.2"]
-              rails-version: ["5.2", "6.0", "6.1", "7.0"]
+              ruby-version: ["2.6", "2.7", "3.0", "3.1", "3.2", "3.3"]
+              rails-version: ["5.2", "6.0", "6.1", "7.0", "7.1", "7.2"]
               database: ["postgresql", "sqlite3", "mysql2"]
             exclude:
               - ruby-version: "3.0"
@@ -57,28 +57,37 @@ workflows:
                 database: "postgresql"
               - ruby-version: "3.0"
                 rails-version: "5.2"
-                database: "sqlite3"
+                database: "mysql2"
               - ruby-version: "3.0"
                 rails-version: "5.2"
-                database: "mysql2"
+                database: "sqlite3"
               - ruby-version: "3.1"
                 rails-version: "5.2"
                 database: "postgresql"
+              - ruby-version: "3.1"
+                rails-version: "5.2"
+                database: "mysql2"
               - ruby-version: "3.1"
                 rails-version: "5.2"
                 database: "sqlite3"
               - ruby-version: "3.2"
                 rails-version: "5.2"
-                database: "mysql2"
+                database: "postgresql"
               - ruby-version: "3.2"
                 rails-version: "5.2"
-                database: "postgresql"
+                database: "mysql2"
               - ruby-version: "3.2"
                 rails-version: "5.2"
                 database: "sqlite3"
-              - ruby-version: "3.1"
+              - ruby-version: "3.3"
+                rails-version: "5.2"
+                database: "postgresql"
+              - ruby-version: "3.3"
                 rails-version: "5.2"
                 database: "mysql2"
+              - ruby-version: "3.3"
+                rails-version: "5.2"
+                database: "sqlite3"
               - ruby-version: "2.6"
                 rails-version: "7.0"
                 database: "postgresql"
@@ -88,3 +97,39 @@ workflows:
               - ruby-version: "2.6"
                 rails-version: "7.0"
                 database: "mysql2"
+              - ruby-version: "2.6"
+                rails-version: "7.1"
+                database: "postgresql"
+              - ruby-version: "2.6"
+                rails-version: "7.1"
+                database: "sqlite3"
+              - ruby-version: "2.6"
+                rails-version: "7.1"
+                database: "mysql2"
+              - ruby-version: "2.6"
+                rails-version: "7.2"
+                database: "postgresql"
+              - ruby-version: "2.6"
+                rails-version: "7.2"
+                database: "sqlite3"
+              - ruby-version: "2.6"
+                rails-version: "7.2"
+                database: "mysql2"
+              - ruby-version: "2.7"
+                rails-version: "7.2"
+                database: "postgresql"
+              - ruby-version: "2.7"
+                rails-version: "7.2"
+                database: "sqlite3"
+              - ruby-version: "2.7"
+                rails-version: "7.2"
+                database: "mysql2"
+              - ruby-version: "3.0"
+                rails-version: "7.2"
+                database: "postgresql"
+              - ruby-version: "3.0"
+                rails-version: "7.2"
+                database: "sqlite3"
+              - ruby-version: "3.0"
+                rails-version: "7.2"
+                database: "mysql2"

data/Appraisals

@@ -3,8 +3,13 @@
   6.0
   6.1
   7.0
+  7.1
+  7.2
 ].each do |rails_version|
   appraise "rails-#{rails_version}" do
     gem 'rails', "~> #{rails_version}.0"
+    if Gem::Version.new(rails_version) < Gem::Version.new("7.2")
+      gem 'sqlite3', "~> 1.4"
+    end
   end
 end

data/CHANGELOG.md

@@ -1,3 +1,33 @@
+## 3.8.0 (October 4, 2024)
+
+New features:
+  - Prefer using `with_connection` where possible (#398)
+
+## 3.7.0 (June 20, 2024)
+
+New features:
+  - Combine multiple updates into a single SQL per target row (#393)
+
+## 3.6.0 (June 18, 2024)
+
+Improvements:
+  - Don't perform a query if the `delta_magnitude` is zero (#394)
+
+## 3.5.3 (February 16, 2024)
+
+Bugfixes:
+  - Correct polymorphic table name alias reference in join clauses (#388)
+
+## 3.5.2 (January 16, 2024)
+
+Bugfixes:
+  - Assign attributes to the duped model on a lower level when determining whether a model has changed to avoid invoking unrelated callbacks (#386)
+
+## 3.5.1 (January 8, 2024)
+
+Bugfixes:
+  - Fix touching for counted models without `updated_at` (#383)
+
 ## 3.5.0 (August 25, 2023)
 
 Improvements:

data/README.md

@@ -7,7 +7,7 @@ Turbo-charged counter caches for your Rails app. Huge improvements over the Rail
 * Supports dynamic column names, making it possible to split up the counter cache for different types of objects
 * Can keep a running count, or a running total
 
-Tested against Ruby 2.6, 2.7, 3.0, 3.1 and 3.2, and against the latest patch releases of Rails 5.2, 6.0, 6.1 and 7.0.
+Tested against Ruby 2.6, 2.7, 3.0, 3.1, 3.2 and 3.3 and against the latest patch releases of Rails 5.2, 6.0, 6.1, 7.0 and 7.1.
 
 Please note that -- unlike Rails' built-in counter-caches -- counter_culture does not currently change the behavior of the `.size` method on ActiveRecord associations. If you want to avoid a database query and read the cached value, please use the attribute name containing the counter cache directly.
 
@@ -74,7 +74,7 @@ class Group < ActiveRecord::Base
   has_many :members, through: :group_memberships, class: "User"
 end
 
-class Membership < ActiveRecord::Base
+class GroupMembership < ActiveRecord::Base
   belongs_to :group
   belongs_to :member, class: "User"
   counter_culture :group, column_name: "members_count"
@@ -285,6 +285,108 @@ You can also pass a `Proc` for dynamic control. This is useful for temporarily m
   counter_culture :category, execute_after_commit: proc { !Thread.current[:update_counter_cache_in_transaction] }
 ```
 
+### Aggregating multiple updates into single SQL queries
+
+>  **NOTE**: This does not have an effect on Papertrail callbacks
+
+By default, every create/update/destroy will trigger separate `UPDATE` SQLs for each action and targeted column. For example, if the creation of 1 record needs to increment 3 counter cache columns, a transaction that creates 3 records of this kind will generate 9 `UPDATE` SQL queries adding `+1` to the value of said columns (3 created records x 3 counter cache columns to be incremented by each).
+
+To avoid this, you can wrap the logic that creates/updates/destroys multiple records in `CounterCulture.aggregate_counter_updates`. This will sum all updates for counter cache columns and will take the latest value for timestamp updates. As a result, you will get just one `UPDATE` SQL query per target record that updates all of its columns at once.
+
+#### Execute aggregated SQL queries before transaction `COMMIT`
+```ruby
+ActiveRecord::Base.transaction do
+  CounterCulture.aggregate_counter_updates do
+    # list of updates
+  end # => executes aggregated SQLs
+end
+```
+
+#### Execute aggregated SQL queries after transaction `COMMIT`
+```ruby
+CounterCulture.aggregate_counter_updates do
+  ActiveRecord::Base.transaction do
+    # list of updates
+  end
+end # => executes aggregated SQLs
+```
+
+#### Examples:
+<details><summary>Sums multiple counter updates for single column of a single target record</summary>
+
+```sql
+-- Before
+UPDATE `authors` SET `authors`.`books_count` = COALESCE(`authors`.`books_count`, 0) + 1 WHERE `authors`.`id` = 1
+UPDATE `authors` SET `authors`.`books_count` = COALESCE(`authors`.`books_count`, 0) + 1 WHERE `authors`.`id` = 1
+UPDATE `authors` SET `authors`.`books_count` = COALESCE(`authors`.`books_count`, 0) + 1 WHERE `authors`.`id` = 1
+UPDATE `authors` SET `authors`.`books_count` = COALESCE(`authors`.`books_count`, 0) - 1 WHERE `authors`.`id` = 1
+
+-- After
+UPDATE `authors` SET `authors`.`books_count` = COALESCE(`authors`.`books_count`, 0) + 2 WHERE `authors`.`id` = 1
+```
+
+```sql
+-- Before
+UPDATE `authors` SET `authors`.`books_count` = COALESCE(`authors`.`books_count`, 0) - 1 WHERE `authors`.`id` = 1
+UPDATE `authors` SET `authors`.`books_count` = COALESCE(`authors`.`books_count`, 0) - 1 WHERE `authors`.`id` = 1
+
+-- After
+UPDATE `authors` SET `authors`.`books_count` = COALESCE(`authors`.`books_count`, 0) + -2 WHERE `authors`.`id` = 1
+```
+
+```sql
+-- Before
+UPDATE `authors` SET `authors`.`books_count` = COALESCE(`authors`.`books_count`, 0) + 1 WHERE `authors`.`id` = 1
+UPDATE `authors` SET `authors`.`books_count` = COALESCE(`authors`.`books_count`, 0) - 1 WHERE `authors`.`id` = 1
+
+-- After
+No query
+```
+
+</details>
+
+<details><summary>Combines multiple updates for multiple columns of a single target record</summary>
+
+```sql
+-- Before
+UPDATE `authors` SET `authors`.`books_count` = COALESCE(`authors`.`books_count`, 0) + 1, updated_at = '2024-06-06 01:00:00' WHERE `authors`.`id` = 1
+UPDATE `authors` SET `authors`.`books_count` = COALESCE(`authors`.`books_count`, 0) + 1, updated_at = '2024-06-06 02:00:00' WHERE `authors`.`id` = 1
+
+-- After
+UPDATE `authors` SET `authors`.`books_count` = COALESCE(`authors`.`books_count`, 0) + 2, updated_at = '2024-06-06 02:00:00' WHERE `authors`.`id` = 1
+```
+
+```sql
+-- Before
+UPDATE `authors` SET `authors`.`books_count` = COALESCE(`authors`.`books_count`, 0) + 1 WHERE `authors`.`id` = 1
+UPDATE `authors` SET `authors`.`works_count` = COALESCE(`authors`.`works_count`, 0) + 1 WHERE `authors`.`id` = 1
+
+-- After
+UPDATE `authors` SET `authors`.`books_count` = COALESCE(`authors`.`books_count`, 0) + 1, `authors`.`works_count` = COALESCE(`authors`.`works_count`, 0) + 1 WHERE `authors`.`id` = 1
+```
+
+</details>
+
+</details>
+
+<details><summary>Combines multiple updates of multiple target records</summary>
+
+```sql
+-- Before
+UPDATE `authors` SET `authors`.`books_count` = COALESCE(`authors`.`books_count`, 0) - 1 WHERE `authors`.`id` = 1
+UPDATE `authors` SET `authors`.`books_count` = COALESCE(`authors`.`books_count`, 0) - 1 WHERE `authors`.`id` = 1
+UPDATE `authors` SET `authors`.`books_count` = COALESCE(`authors`.`books_count`, 0) - 1 WHERE `authors`.`id` = 1
+UPDATE `authors` SET `authors`.`books_count` = COALESCE(`authors`.`books_count`, 0) + 1 WHERE `authors`.`id` = 2
+UPDATE `authors` SET `authors`.`books_count` = COALESCE(`authors`.`books_count`, 0) + 1 WHERE `authors`.`id` = 2
+UPDATE `authors` SET `authors`.`books_count` = COALESCE(`authors`.`books_count`, 0) + 1 WHERE `authors`.`id` = 2
+
+-- After
+UPDATE `authors` SET `authors`.`books_count` = COALESCE(`authors`.`books_count`, 0) + -3 WHERE `authors`.`id` = 1
+UPDATE `authors` SET `authors`.`books_count` = COALESCE(`authors`.`books_count`, 0) + 3 WHERE `authors`.`id` = 2
+```
+
+</details>
+
 ### Manually populating counter cache values
 
 You will sometimes want to populate counter-cache values from primary data. This is required when adding counter-caches to existing data. It is also recommended to run this regularly (at BestVendor, we run it once a week) to catch any incorrect values in the counter caches.
@@ -358,6 +460,8 @@ Product.counter_culture_fix_counts touch: 'category_count_changed'
 
 The options start and finish are especially useful if you want multiple workers dealing with the same processing queue. You can make worker 1 handle all the records between id 1 and 9999 and worker 2 handle from 10000 and beyond by setting the :start and :finish option on each worker.
 
+>  **! NOTE**: the IDs we pass as `start` and `finish` here are in fact `Category` IDs, not `Product`!
+
 ```ruby
 Product.counter_culture_fix_counts start: 10_000
 # will fix counts for all counter caches defined on Product from record 10000 and onwards.
@@ -374,7 +478,7 @@ Product.counter_culture_fix_counts start: 2001, finish: 3000
 
 #### Fix counter cache using a replica database
 
-When fixing counter caches the number of reads usually vastly exceeds the number of writes. It can make sense to offload the road load to a replica database in this case. Rails 6 introduced [native handling of multiple database connections](https://guides.rubyonrails.org/v6.0/active_record_multiple_databases.html). You can use this to send read traffic to a read-only repliace using the option `db_connection_builder`:
+When fixing counter caches the number of reads usually vastly exceeds the number of writes. It can make sense to offload the read load to a replica database in this case. Rails 6 introduced [native handling of multiple database connections](https://guides.rubyonrails.org/v6.0/active_record_multiple_databases.html). You can use this to send read traffic to a read-only replica using the option `db_connection_builder`:
 
 ```ruby
 Product.counter_culture_fix_counts db_connection_builder: proc{|reading, block|

data/counter_culture.gemspec

@@ -43,7 +43,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'rspec-extra-formatters'
   spec.add_development_dependency 'simplecov', '~> 0.16.1'
   spec.add_development_dependency 'timecop'
-  spec.add_development_dependency 'sqlite3'
+  spec.add_development_dependency 'sqlite3', ">= 1.4"
   spec.add_development_dependency 'mysql2'
   spec.add_development_dependency 'pg'
 end

data/gemfiles/rails_5.2.gemfile

@@ -3,5 +3,6 @@
 source "https://rubygems.org"
 
 gem "rails", "~> 5.2.0"
+gem "sqlite3", "~> 1.4"
 
 gemspec path: "../"

data/gemfiles/rails_6.0.gemfile

@@ -3,5 +3,6 @@
 source "https://rubygems.org"
 
 gem "rails", "~> 6.0.0"
+gem "sqlite3", "~> 1.4"
 
 gemspec path: "../"

data/gemfiles/rails_6.1.gemfile

@@ -3,5 +3,6 @@
 source "https://rubygems.org"
 
 gem "rails", "~> 6.1.0"
+gem "sqlite3", "~> 1.4"
 
 gemspec path: "../"

data/gemfiles/rails_7.0.gemfile

@@ -3,5 +3,6 @@
 source "https://rubygems.org"
 
 gem "rails", "~> 7.0.0"
+gem "sqlite3", "~> 1.4"
 
 gemspec path: "../"

data/gemfiles/rails_7.1.gemfile

@@ -0,0 +1,8 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "rails", "~> 7.1.0"
+gem "sqlite3", "~> 1.4"
+
+gemspec path: "../"

data/gemfiles/rails_7.2.gemfile

@@ -0,0 +1,7 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "rails", "~> 7.2.0"
+
+gemspec path: "../"

data/lib/counter_culture/counter.rb

@@ -1,3 +1,5 @@
+require_relative './with_connection'
+
 module CounterCulture
   class Counter
     CONFIG_OPTIONS = [ :column_names, :counter_cache_name, :delta_column, :foreign_key_values, :touch, :delta_magnitude, :execute_after_commit ]
@@ -55,6 +57,8 @@ module CounterCulture
                           else
                             counter_delta_magnitude_for(obj)
                           end
+        return if delta_magnitude.zero?
+
         # increment or decrement?
         operator = options[:increment] ? '+' : '-'
 
@@ -63,38 +67,51 @@ module CounterCulture
         # MySQL throws an ambiguous column error if any joins are present and we don't include the
         # table name. We isolate this change to MySQL because sqlite has the opposite behavior and
         # throws an exception if the table name is present after UPDATE.
-        quoted_column = if klass.connection.adapter_name == 'Mysql2'
-                          "#{klass.quoted_table_name}.#{model.connection.quote_column_name(change_counter_column)}"
-                        else
-                          "#{model.connection.quote_column_name(change_counter_column)}"
-                        end
+        quoted_column = WithConnection.new(klass).call do |connection|
+          if connection.adapter_name == 'Mysql2'
+            "#{klass.quoted_table_name}.#{connection.quote_column_name(change_counter_column)}"
+          else
+            "#{connection.quote_column_name(change_counter_column)}"
+          end
+        end
 
         column_type = klass.type_for_attribute(change_counter_column).type
 
         # we don't use Rails' update_counters because we support changing the timestamp
         updates = []
-        # this updates the actual counter
-        if column_type == :money
-          updates << "#{quoted_column} = COALESCE(CAST(#{quoted_column} as NUMERIC), 0) #{operator} #{delta_magnitude}"
+
+        # this will update the actual counter
+        updates << if column_type == :money
+          assemble_money_counter_update(klass, id_to_change, quoted_column, operator, delta_magnitude)
         else
-          updates << "#{quoted_column} = COALESCE(#{quoted_column}, 0) #{operator} #{delta_magnitude}"
+          assemble_counter_update(klass, id_to_change, quoted_column, operator, delta_magnitude)
         end
-        # and here we update the timestamp, if so desired
+
+        # and this will update the timestamp, if so desired
         if touch
-          current_time = obj.send(:current_time_from_proper_timezone)
-          timestamp_columns = obj.send(:timestamp_attributes_for_update_in_model)
+          current_time = klass.send(:current_time_from_proper_timezone)
+          timestamp_columns = klass.send(:timestamp_attributes_for_update_in_model)
           if touch != true
             # starting in Rails 6 this is frozen
             timestamp_columns = timestamp_columns.dup
             timestamp_columns << touch
           end
           timestamp_columns.each do |timestamp_column|
-            updates << "#{timestamp_column} = '#{current_time.to_formatted_s(:db)}'"
+            updates << assemble_timestamp_update(
+              klass,
+              id_to_change,
+              timestamp_column,
+              -> { klass.send(:current_time_from_proper_timezone).to_formatted_s(:db) }
+            )
           end
         end
 
         primary_key = relation_primary_key(relation, source: obj, was: options[:was])
 
+        if Thread.current[:aggregate_counter_updates]
+          Thread.current[:primary_key_map][klass] ||= primary_key
+        end
+
         if @with_papertrail
           instance = klass.where(primary_key => id_to_change).first
           if instance
@@ -118,8 +135,10 @@ module CounterCulture
           end
         end
 
-        execute_now_or_after_commit(obj) do
-          klass.where(primary_key => id_to_change).update_all updates.join(', ')
+        unless Thread.current[:aggregate_counter_updates]
+          execute_now_or_after_commit(obj) do
+            klass.where(primary_key => id_to_change).update_all updates.join(', ')
+          end
         end
       end
     end
@@ -165,7 +184,7 @@ module CounterCulture
     def foreign_key_value(obj, relation, was = false)
       original_relation = relation
       relation = relation.is_a?(Enumerable) ? relation.dup : [relation]
-      
+
       if was
         first = relation.shift
         foreign_key_value = attribute_was(obj, relation_foreign_key(first))
@@ -314,7 +333,9 @@ module CounterCulture
       changes_method = ACTIVE_RECORD_VERSION >= Gem::Version.new("5.1.0") ? :saved_changes : :changed_attributes
       obj.public_send(changes_method).each do |key, value|
         old_value = ACTIVE_RECORD_VERSION >= Gem::Version.new("5.1.0") ? value.first : value
-        prev[key] = old_value
+        # We set old values straight to AR @attributes variable to avoid
+        # write_attribute callbacks from other gems (e.g. ArTransactionChanges)
+        prev.instance_variable_get(:@attributes).write_from_user(key, old_value)
       end
 
       prev
@@ -331,6 +352,7 @@ module CounterCulture
     end
 
     private
+
     def attribute_was(obj, attr)
       changes_method =
         if ACTIVE_RECORD_VERSION >= Gem::Version.new("5.1.0")
@@ -340,5 +362,63 @@ module CounterCulture
         end
       obj.public_send("#{attr}#{changes_method}")
     end
+
+    def assemble_money_counter_update(klass, id_to_change, quoted_column, operator, delta_magnitude)
+      counter_update_snippet(
+        "#{quoted_column} = COALESCE(CAST(#{quoted_column} as NUMERIC), 0)",
+        klass,
+        id_to_change,
+        operator,
+        delta_magnitude
+      )
+    end
+
+    def assemble_counter_update(klass, id_to_change, quoted_column, operator, delta_magnitude)
+      counter_update_snippet(
+        "#{quoted_column} = COALESCE(#{quoted_column}, 0)",
+        klass,
+        id_to_change,
+        operator,
+        delta_magnitude
+      )
+    end
+
+    def assemble_timestamp_update(klass, id_to_change, timestamp_column, value)
+      update = "#{timestamp_column} ="
+
+      if Thread.current[:aggregate_counter_updates]
+        remember_timestamp_update(klass, id_to_change, update, value)
+      else
+        "#{update} '#{value.call}'"
+      end
+    end
+
+    def counter_update_snippet(update, klass, id_to_change, operator, delta_magnitude)
+      if Thread.current[:aggregate_counter_updates]
+        remember_counter_update(
+          klass,
+          id_to_change,
+          "#{update} +",
+          operator == '+' ? delta_magnitude : -delta_magnitude
+        )
+      else
+        "#{update} #{operator} #{delta_magnitude}"
+      end
+    end
+
+    def remember_counter_update(klass, id, operation, value)
+      Thread.current[:aggregated_updates][klass] ||= {}
+      Thread.current[:aggregated_updates][klass][id] ||= {}
+      Thread.current[:aggregated_updates][klass][id][operation] ||= 0
+
+      Thread.current[:aggregated_updates][klass][id][operation] += value
+    end
+
+    def remember_timestamp_update(klass, id, operation, value)
+      Thread.current[:aggregated_updates][klass] ||= {}
+      Thread.current[:aggregated_updates][klass][id] ||= {}
+
+      Thread.current[:aggregated_updates][klass][id][operation] = value
+    end
   end
 end

data/lib/counter_culture/reconciler.rb

@@ -1,6 +1,8 @@
 require 'active_support/core_ext/module/delegation'
 require 'active_support/core_ext/module/attribute_accessors'
 
+require_relative './with_connection'
+
 module CounterCulture
   class Reconciler
     ACTIVE_RECORD_VERSION = Gem.loaded_specs["activerecord"].version
@@ -274,13 +276,13 @@ module CounterCulture
           # child in a Single Table Inheritance
           if reflect.active_record.column_names.include?('type') &&
               !model.descends_from_active_record?
-            joins_sql += " AND #{target_table}.type IN ('#{model.name}')"
+            joins_sql += " AND #{target_table_alias}.type IN ('#{model.name}')"
           end
           if polymorphic?
             # adds 'type' condition to JOIN clause if the current model is a
             # polymorphic relation
             # NB only works for one-level relations
-            joins_sql += " AND #{target_table}.#{reflect.foreign_type} = '#{relation_class.name}'"
+            joins_sql += " AND #{target_table_alias}.#{reflect.foreign_type} = '#{relation_class.name}'"
           end
           if index == reverse_relation.size - 1
             # conditions must be applied to the join on which we are counting
@@ -312,7 +314,9 @@ module CounterCulture
       # using Postgres with schema-namespaced tables. But then it's required,
       # and otherwise it's just a no-op, so why not do it?
       def quote_table_name(table_name)
-        relation_class.connection.quote_table_name(table_name)
+        WithConnection.new(relation_class).call do |connection|
+          connection.quote_table_name(table_name)
+        end
       end
 
       def parameterize(string)

data/lib/counter_culture/version.rb

@@ -1,3 +1,3 @@
 module CounterCulture
-  VERSION = '3.5.0'.freeze
+  VERSION = '3.8.0'.freeze
 end

data/lib/counter_culture/with_connection.rb

@@ -0,0 +1,33 @@
+module CounterCulture
+  class WithConnection
+    def initialize(recipient)
+      @recipient = recipient
+    end
+
+    attr_reader :recipient
+
+    def call
+      if rails_7_2_or_greater?
+        recipient.with_connection do |connection|
+          yield connection
+        end
+      elsif rails_7_1?
+        recipient.connection_pool.with_connection do |connection|
+          yield connection
+        end
+      else
+        yield recipient.connection
+      end
+    end
+
+    private
+
+    def rails_7_1?
+      Gem::Requirement.new('~> 7.1.0').satisfied_by?(Gem::Version.new(Rails.version))
+    end
+
+    def rails_7_2_or_greater?
+      Gem::Requirement.new('>= 7.2.0').satisfied_by?(Gem::Version.new(Rails.version))
+    end
+  end
+end

data/lib/counter_culture.rb

@@ -15,6 +15,38 @@ module CounterCulture
     yield(self) if block_given?
     self
   end
+
+  def self.aggregate_counter_updates
+    return unless block_given?
+
+    Thread.current[:aggregate_counter_updates] = true
+    Thread.current[:aggregated_updates] = {}
+    Thread.current[:primary_key_map] = {}
+
+    result = yield
+
+    # aggregate the updates for each target record and execute SQL queries
+    Thread.current[:aggregated_updates].each do |klass, attrs|
+      attrs.each do |rec_id, updates|
+        update_snippets = updates.map do |operation, value|
+          value = value.call if value.is_a?(Proc)
+          %Q{#{operation} #{value.is_a?(String) ? "'#{value}'" : value}} unless value == 0
+        end.compact
+
+        if update_snippets.any?
+          klass
+            .where(Thread.current[:primary_key_map][klass] => rec_id)
+            .update_all(update_snippets.join(', '))
+        end
+      end
+    end
+
+    result
+  ensure
+    Thread.current[:aggregate_counter_updates] = false
+    Thread.current[:aggregated_updates] = nil
+    Thread.current[:primary_key_map] = nil
+  end
 end
 
 # extend ActiveRecord with our own code here

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: counter_culture
 version: !ruby/object:Gem::Version
-  version: 3.5.0
+  version: 3.8.0
 platform: ruby
 authors:
 - Magnus von Koeller
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-08-25 00:00:00.000000000 Z
+date: 2024-10-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -254,14 +254,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.4'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.4'
 - !ruby/object:Gem::Dependency
   name: mysql2
   requirement: !ruby/object:Gem::Requirement
@@ -317,12 +317,15 @@ files:
 - gemfiles/rails_6.0.gemfile
 - gemfiles/rails_6.1.gemfile
 - gemfiles/rails_7.0.gemfile
+- gemfiles/rails_7.1.gemfile
+- gemfiles/rails_7.2.gemfile
 - lib/counter_culture.rb
 - lib/counter_culture/counter.rb
 - lib/counter_culture/extensions.rb
 - lib/counter_culture/reconciler.rb
 - lib/counter_culture/skip_updates.rb
 - lib/counter_culture/version.rb
+- lib/counter_culture/with_connection.rb
 - lib/generators/counter_culture_generator.rb
 - lib/generators/templates/counter_culture_migration.rb.erb
 homepage: https://github.com/magnusvk/counter_culture
@@ -344,7 +347,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.19
+rubygems_version: 3.5.10
 signing_key:
 specification_version: 4
 summary: Turbo-charged counter caches for your Rails app.