activerecord-slotted_counters 0.0.1 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8f3309ca0e6671a6dbb844a5e3c7e8f0bf289b6125e9cbbed9d8234ed2afb596
-  data.tar.gz: be5e21d8aea9e6dc73a0150bed7cf13f349a6af7dc71cbe38cc86bd0ed785e3c
+  metadata.gz: 5dcee16f487cc8b48e6fb4c4b84069cc97b9647d5e710fa8d8c2e25038620815
+  data.tar.gz: 43b9d1432b7aa8088c1508038d8927cf4aca1e8e33e3a159a3b915b7037f8084
 SHA512:
-  metadata.gz: 5ec60f4a1eaeff23861b5c1fe7ba6ea2ab866097f2f3d2ced182fcf36c82b34d402a536f37567423f3cdb4b9fe7baa5ca3d434d99fe2235adaeb30ebc0348493
-  data.tar.gz: fcee85f67d01bc7a4938fc7b261962157ee96d7db69e65003f9091fcffc9d6776fc3b905f6efb6516aeeaa95ae2ac104826671b00e030948f90675dcee4f20c8
+  metadata.gz: 9783f3d0166756156a12e2337539acca146ebb8cbec1298d3b3b06a8721c2a23c18e61bc38c2944cd2fb999f798129e30ef608c4f862fad4e3d7628573cd49d3
+  data.tar.gz: a6a250dd5daed59fd0495954c9220e02de57e99232d2e19f7e159d9f838d4ad6b2a90acc3ece9f466a829afc99467ec4ef096130827be9d3ba13197c665cb367

data/CHANGELOG.md

@@ -2,4 +2,14 @@
 
 ## master
 
+## 0.1.1 (2023-01-17)
+
+- Fix prevent double increment/decrement of native counter caches [#10](https://github.com/evilmartians/activerecord-slotted_counters/pull/10) ([@danielwestendorf][])
+
+## 0.1.0 (2022-11-29)
+
+- Initial release.
+
 [@palkan]: https://github.com/palkan
+[@LukinEgor]: https://github.com/LukinEgor
+[@danielwestendorf]: https://github.com/danielwestendorf

data/README.md

@@ -2,10 +2,17 @@
 
 # Active Record slotted counters
 
-This gem adds **slotted counters** support to [Active Record counter cache][counter-cache]. Slotted counters help to reduce contention on a single row update in case you many concurrent operations (like updating a page views counter during traffic spikes).
+This gem adds **slotted counters** support to [Active Record counter cache][counter-cache]. Slotted counters help to reduce contention on a single row update in case you have many concurrent operations (like updating a page views counter during traffic spikes).
 
 Read more about slotted counters in [this post](https://planetscale.com/blog/the-slotted-counter-pattern).
 
+<p align="center">
+  <a href="https://evilmartians.com/?utm_source=active-record-slotted-counters">
+    <img src="https://evilmartians.com/badges/sponsored-by-evil-martians.svg"
+         alt="Sponsored by Evil Martians" width="236" height="54">
+  </a>
+</p>
+
 ## Installation
 
 Add to your project:
@@ -56,11 +63,11 @@ Under the hood, a row in the `slotted_counters` table is created associated with
 **NOTE:** Reading the current value performs SQL query once:
 
 ```ruby
-user.comments_count #=> select count from slotted_counters where ...
+user.comments_count #=> select * from slotted_counters where ...
 user.comments_count #=> no sql
 ```
 
-If you want to want preload counters for multiple records, you can use a convinient `#with_slotted_counters` method:
+If you want to want preload counters for multiple records, you can use a convenient `#with_slotted_counters` method:
 
 ```ruby
 User.all.with_slotted_counters(:comments).find_each do
@@ -72,10 +79,6 @@ Using `counter_cache: true` on `belongs_to` associations also works as expected.
 
 ## Limitations / TODO
 
-- Add `reset_counters` implementation
-- Add `update_counters` implementation
-- Add `with_slotted_counters` scope
-- Add multiple `has_slotted_counter` support
 - Rails 6 support
 
 ## Contributing

data/lib/activerecord_slotted_counters/has_slotted_counter.rb

@@ -10,6 +10,15 @@ module ActiveRecordSlottedCounters
     end
   end
 
+  module BelongsToAssociation
+    def update_counters_via_scope(klass, foreign_key, by)
+      counter_name = reflection.counter_cache_column
+      return super unless klass.registered_slotted_counter? counter_name
+
+      klass.update_counters(foreign_key, counter_name => by, :touch => reflection.options[:touch])
+    end
+  end
+
   module HasSlottedCounter
     extend ActiveSupport::Concern
     include ActiveRecordSlottedCounters::Utils
@@ -29,7 +38,12 @@ module ActiveRecordSlottedCounters
         counter_name = slotted_counter_name(counter_type)
         association_name = slotted_counter_association_name(counter_type)
 
-        has_many association_name, **SLOTTED_COUNTERS_ASSOCIATION_OPTIONS
+        has_many association_name, ->(model) { associated_records(counter_name, model.id, model.class.to_s) }, **SLOTTED_COUNTERS_ASSOCIATION_OPTIONS
+
+        scope :with_slotted_counters, ->(counter_type) do
+          association_name = slotted_counter_association_name(counter_type)
+          preload(association_name)
+        end
 
         _slotted_counters << counter_type
 
@@ -38,16 +52,39 @@ module ActiveRecordSlottedCounters
         end
       end
 
-      def increment_counter(counter_name, id, touch: nil)
-        return super unless registered_slotted_counter? counter_name
+      def update_counters(id, counters)
+        touch = counters.delete(:touch)
+
+        updated_counters_count = 0
+        registered_counters, unregistered_counters = counters.partition { |name, _| registered_slotted_counter? name }.map(&:to_h)
+
+        if unregistered_counters.present?
+          unregistered_counters[:touch] = touch
+          updated_unregistered_counters_count = super(id, unregistered_counters)
+          updated_counters_count += updated_unregistered_counters_count
+        end
+
+        if registered_counters.present?
+          ids = Array(id)
+          updated_registered_counters_count = update_slotted_counters(ids, registered_counters, touch)
+          updated_counters_count += updated_registered_counters_count
+        end
 
-        insert_counter_record(counter_name, id, 1)
+        updated_counters_count
       end
 
-      def decrement_counter(counter_name, id, touch: nil)
-        return super unless registered_slotted_counter? counter_name
+      def reset_counters(id, *counters, touch: nil)
+        registered_counters, unregistered_counters = counters.partition { |name| registered_slotted_counter? slotted_counter_name(name) }
 
-        insert_counter_record(counter_name, id, -1)
+        if unregistered_counters.present?
+          super(id, *unregistered_counters, touch: touch)
+        end
+
+        if registered_counters.present?
+          reset_slotted_counters(id, *registered_counters, touch: touch)
+        end
+
+        true
       end
 
       def slotted_counters
@@ -58,36 +95,96 @@ module ActiveRecordSlottedCounters
         end
       end
 
+      def registered_slotted_counter?(counter_name)
+        counter_type = slotted_counter_type(counter_name)
+
+        slotted_counters.include? counter_type
+      end
+
+      def update_slotted_counters(ids, registered_counters, touch)
+        updated_counters_count = 0
+        ActiveRecord::Base.transaction do
+          updated_counters_count = insert_counters_records(ids, registered_counters)
+          touch_attributes(ids, touch) if touch.present?
+        end
+
+        updated_counters_count
+      end
+
       private
 
       def _slotted_counters
         @_slotted_counters ||= []
       end
 
-      def registered_slotted_counter?(counter_name)
-        counter_type = slotted_counter_type(counter_name)
+      def reset_slotted_counters(id, *counters, touch: nil)
+        object = find(id)
 
-        slotted_counters.include? counter_type
+        counters.each do |counter_association|
+          has_many_association = _reflect_on_association(counter_association)
+          raise ArgumentError, "'#{name}' has no association called '#{counter_association}'" unless has_many_association
+
+          counter_name = slotted_counter_name counter_association
+
+          ActiveRecord::Base.transaction do
+            counter_value = object.send(counter_association).count(:all)
+            updates = {counter_name => counter_value}
+            remove_counters_records([id], counter_name)
+            insert_counters_records([id], updates)
+            touch_attributes([id], touch) if touch.present?
+          end
+        end
       end
 
-      def insert_counter_record(counter_name, id, count)
-        slot = rand(DEFAULT_MAX_SLOT_NUMBER)
-        on_duplicate_clause = "count = slotted_counters.count + #{count}"
-
-        result = ActiveRecordSlottedCounters::SlottedCounter.upsert(
-          {
-            counter_name: counter_name,
-            associated_record_type: name,
-            associated_record_id: id,
-            slot: slot,
-            count: count
-          },
+      def insert_counters_records(ids, counters)
+        counters_params = prepare_slotted_counters_params(ids, counters)
+        on_duplicate_clause = "count = slotted_counters.count + excluded.count"
+
+        result = ActiveRecordSlottedCounters::SlottedCounter.upsert_all(
+          counters_params,
           on_duplicate: Arel.sql(on_duplicate_clause),
           unique_by: :index_slotted_counters
         )
 
         result.rows.count
       end
+
+      def remove_counters_records(ids, counter_name)
+        ActiveRecordSlottedCounters::SlottedCounter.where(
+          counter_name: counter_name,
+          associated_record_type: name,
+          associated_record_id: ids
+        ).delete_all
+      end
+
+      def touch_attributes(ids, touch)
+        scope = where(id: ids)
+        return scope.touch_all if touch == true
+
+        scope.touch_all(touch)
+      end
+
+      def prepare_slotted_counters_params(ids, counters)
+        counters.map do |counter_name, count|
+          slot = rand(DEFAULT_MAX_SLOT_NUMBER)
+
+          ids.map do |id|
+            {
+              counter_name: counter_name,
+              associated_record_type: name,
+              associated_record_id: id,
+              slot: slot,
+              count: count
+            }
+          end
+        end.flatten
+      end
+    end
+
+    def increment!(attribute, by = 1, touch: nil)
+      return super unless self.class.registered_slotted_counter? attribute
+
+      self.class.update_counters(id, attribute => by, :touch => touch)
     end
 
     private
@@ -102,8 +199,7 @@ module ActiveRecordSlottedCounters
         return counter
       end
 
-      counter_name = slotted_counter_name(counter_type)
-      scope = send(association_name).associated_records(counter_name, id, self.class.to_s)
+      scope = send(association_name)
       scope.sum(:count)
     end
   end

data/lib/activerecord_slotted_counters/railtie.rb

@@ -10,6 +10,8 @@ module ActiveRecordSlottedCounters # :nodoc:
     initializer "extend ActiveRecord with  ActiveRecordSlottedCounters" do |_app|
       ActiveSupport.on_load(:active_record) do
         ActiveRecord::Base.include ActiveRecordSlottedCounters::HasSlottedCounter
+        ActiveRecord::Relation.include ActiveRecordSlottedCounters::Utils
+        ActiveRecord::Associations::BelongsToAssociation.prepend ActiveRecordSlottedCounters::BelongsToAssociation
       end
     end
   end

data/lib/activerecord_slotted_counters/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ActiveRecordSlottedCounters # :nodoc:
-  VERSION = "0.0.1"
+  VERSION = "0.1.1"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-slotted_counters
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.1
 platform: ruby
 authors:
 - Egor Lukin
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-09-05 00:00:00.000000000 Z
+date: 2023-01-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord