counter_culture 3.6.0 → 3.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5f4fd84b17129a9385e310381e0a19d5dc94a77f99bc6375e296cbf88c08fe72
-  data.tar.gz: a717e7ce645837b369e9fa5d40f7e721efaa8815b0ece0d814e124b798ede467
+  metadata.gz: 88687e8c584a1643026e8e09d9f64484110fd7a19ebf1faa6cb311361e8c35ca
+  data.tar.gz: a81ac645489129472e265f3bfefa0573f11a9e8419a40ba7f4c687c692367177
 SHA512:
-  metadata.gz: 74b120975400617101789ac7721b839e57e210e68a28d1edc307e2b8e03086e0d6adc652cb9a96be7cd0a7921c7e8033216316d63f0c74da9e3b929a9d24ad39
-  data.tar.gz: 050d42b195d1c947aa79f8cbbaf2dea74441020c67b96aa2493463c6cdcf0a1ccb649b7a322921174a64a30f4ba9287a0450ab217915dd62844adafdc5f934cd
+  metadata.gz: 82ffa1af6e6ad80f68a56b77cdae1f68dd30aa63535281f4ee19ee3ad1e5f88cc7053ae4cab6f1786db7038baeb81cf5c434b1b657f886b62862d79b0d99d7dc
+  data.tar.gz: 83e5c626c97583727a5cbef6c824dd5eb25625d169a53e65e73bd1d2ab633121bb2a1a2de430a2d522caa92382b5852d731e0f954818fa906ab2b0060986119a

data/CHANGELOG.md

@@ -1,3 +1,8 @@
+## 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/lib/counter_culture/counter.rb

@@ -75,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)
@@ -91,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
@@ -120,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
@@ -167,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))
@@ -335,6 +348,7 @@ module CounterCulture
     end
 
     private
+
     def attribute_was(obj, attr)
       changes_method =
         if ACTIVE_RECORD_VERSION >= Gem::Version.new("5.1.0")
@@ -344,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.6.0'.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.6.0
+  version: 3.7.0
 platform: ruby
 authors:
 - Magnus von Koeller
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-06-18 00:00:00.000000000 Z
+date: 2024-06-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord