counter_culture 3.6.0 → 3.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5f4fd84b17129a9385e310381e0a19d5dc94a77f99bc6375e296cbf88c08fe72
-  data.tar.gz: a717e7ce645837b369e9fa5d40f7e721efaa8815b0ece0d814e124b798ede467
+  metadata.gz: 225d25bff8cd9226371b162e6761603271cbac02c74be1dd7398de2dc63dbb71
+  data.tar.gz: ea2b215508e285bab75efcbf3aeb153a15458c22db0cc0b79350bb2e9b3a9e05
 SHA512:
-  metadata.gz: 74b120975400617101789ac7721b839e57e210e68a28d1edc307e2b8e03086e0d6adc652cb9a96be7cd0a7921c7e8033216316d63f0c74da9e3b929a9d24ad39
-  data.tar.gz: 050d42b195d1c947aa79f8cbbaf2dea74441020c67b96aa2493463c6cdcf0a1ccb649b7a322921174a64a30f4ba9287a0450ab217915dd62844adafdc5f934cd
+  metadata.gz: 5362e9b1db5c4a81944e3deeddec9c7945ae349cca9f663dae140fb1516f00b9bd41d4d34af4705c2d4600ee65dabe2a41bc0a53e1a98ba682385228b0f4e41a
+  data.tar.gz: 60d99dab523e3f339961c4d19393f27de41006c361dc190baf25676157dded5b98382d77cca3dd76533cb070e3eec14965bb90ffe3f13991ba6d409cdf3e779a

data/.circleci/config.yml

@@ -49,7 +49,7 @@ workflows:
           matrix:
             parameters:
               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"]
+              rails-version: ["5.2", "6.0", "6.1", "7.0", "7.1", "7.2"]
               database: ["postgresql", "sqlite3", "mysql2"]
             exclude:
               - ruby-version: "3.0"
@@ -106,3 +106,30 @@ workflows:
               - 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

@@ -4,6 +4,7 @@
   6.1
   7.0
   7.1
+  7.2
 ].each do |rails_version|
   appraise "rails-#{rails_version}" do
     gem 'rails', "~> #{rails_version}.0"

data/CHANGELOG.md

@@ -1,3 +1,13 @@
+## 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:

data/README.md

@@ -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.

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 ]
@@ -65,23 +67,27 @@ 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 = klass.send(:current_time_from_proper_timezone)
           timestamp_columns = klass.send(:timestamp_attributes_for_update_in_model)
@@ -91,12 +97,21 @@ module CounterCulture
             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
@@ -120,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
@@ -167,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))
@@ -335,6 +352,7 @@ module CounterCulture
     end
 
     private
+
     def attribute_was(obj, attr)
       changes_method =
         if ACTIVE_RECORD_VERSION >= Gem::Version.new("5.1.0")
@@ -344,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
@@ -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.6.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.6.0
+  version: 3.8.0
 platform: ruby
 authors:
 - Magnus von Koeller
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-06-18 00:00:00.000000000 Z
+date: 2024-10-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -318,12 +318,14 @@ files:
 - 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