counter_culture 3.5.3 → 3.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7c2646918dbfacac2d3d3f923c601111bfcf58b46b1ba0ed035e9f8a557b9577
-  data.tar.gz: 52cd080e6eb8beb589c8cfb52e73ad62fe333caea4c91d9098cbb5a78ff8f30f
+  metadata.gz: 88687e8c584a1643026e8e09d9f64484110fd7a19ebf1faa6cb311361e8c35ca
+  data.tar.gz: a81ac645489129472e265f3bfefa0573f11a9e8419a40ba7f4c687c692367177
 SHA512:
-  metadata.gz: b8736342d26f93e1cba9372057d941b216efda9bcefe8f56215b001b987e0a557f82e632376879a9006bf2b1d58cf876682f23efe7f6fb3912232d8de58442ea
-  data.tar.gz: a92f08b7574babb1c2e79b634b3f418f3e37e7d8b83abbddd8d1d9e909e4c073034b1f1b4f5534de5d9136967dc1863fcfec0a2f49e1c7620930d5c5ece617e9
+  metadata.gz: 82ffa1af6e6ad80f68a56b77cdae1f68dd30aa63535281f4ee19ee3ad1e5f88cc7053ae4cab6f1786db7038baeb81cf5c434b1b657f886b62862d79b0d99d7dc
+  data.tar.gz: 83e5c626c97583727a5cbef6c824dd5eb25625d169a53e65e73bd1d2ab633121bb2a1a2de430a2d522caa92382b5852d731e0f954818fa906ab2b0060986119a

data/Appraisals

@@ -7,5 +7,8 @@
 ].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,13 @@
+## 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:

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/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

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

data/lib/counter_culture/counter.rb

@@ -55,6 +55,8 @@ module CounterCulture
                           else
                             counter_delta_magnitude_for(obj)
                           end
+        return if delta_magnitude.zero?
+
         # increment or decrement?
         operator = options[:increment] ? '+' : '-'
 
@@ -73,13 +75,15 @@ module CounterCulture
 
         # 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)
@@ -89,12 +93,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
@@ -118,8 +131,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 +180,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))
@@ -333,6 +348,7 @@ module CounterCulture
     end
 
     private
+
     def attribute_was(obj, attr)
       changes_method =
         if ACTIVE_RECORD_VERSION >= Gem::Version.new("5.1.0")
@@ -342,5 +358,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/version.rb

@@ -1,3 +1,3 @@
 module CounterCulture
-  VERSION = '3.5.3'.freeze
+  VERSION = '3.7.0'.freeze
 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.3
+  version: 3.7.0
 platform: ruby
 authors:
 - Magnus von Koeller
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-02-17 00:00:00.000000000 Z
+date: 2024-06-20 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
@@ -345,7 +345,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.