activerecord-slotted_counters 0.1.1 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5dcee16f487cc8b48e6fb4c4b84069cc97b9647d5e710fa8d8c2e25038620815
-  data.tar.gz: 43b9d1432b7aa8088c1508038d8927cf4aca1e8e33e3a159a3b915b7037f8084
+  metadata.gz: bdd6573e6f4d045624e5d0e068f40728ece0ff47461b0c476606689b74de6c7d
+  data.tar.gz: 79fc88a8fd00ff709b34b9cfd192a9275b95647639281ee36f10e2b61b5eb79a
 SHA512:
-  metadata.gz: 9783f3d0166756156a12e2337539acca146ebb8cbec1298d3b3b06a8721c2a23c18e61bc38c2944cd2fb999f798129e30ef608c4f862fad4e3d7628573cd49d3
-  data.tar.gz: a6a250dd5daed59fd0495954c9220e02de57e99232d2e19f7e159d9f838d4ad6b2a90acc3ece9f466a829afc99467ec4ef096130827be9d3ba13197c665cb367
+  metadata.gz: d2fdb9401b2473f9d1ea8048bc14056665a310fe52fb4c0e1572b989ddab04f4907fa15df57821f7792b8861bd1d07259da9ddef425281c423c68d37e922ebbe
+  data.tar.gz: 5e399bc56136750d40f5303677ce381ae791a56a96f52ac2df9b1c6f7ca6443c4eaef2cad71b631231d043023f1e6a1a8643f54bb607afd68c73462cdafc25db

data/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 ## master
 
+## 0.1.3 (2023-04-03)
+
+- Add Rails 6 support (PostgreSQL only) [#13](https://github.com/evilmartians/activerecord-slotted_counters/pull/13) ([@LukinEgor][])
+
+## 0.1.2 (2023-03-28)
+
+- Fix preloading counters for multiple records [#12](https://github.com/evilmartians/activerecord-slotted_counters/pull/12) ([@LukinEgor][])
+
 ## 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][])

data/README.md

@@ -79,7 +79,7 @@ Using `counter_cache: true` on `belongs_to` associations also works as expected.
 
 ## Limitations / TODO
 
-- Rails 6 support
+- Gem supports only PostgreSQL for Rails 6
 
 ## Contributing
 

data/lib/activerecord_slotted_counters/adapters/pg_upsert.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module ActiveRecordSlottedCounters
+  module Adapters
+    class PgUpsert
+      attr_reader :klass
+
+      def initialize(klass)
+        @klass = klass
+      end
+
+      def apply?
+        ActiveRecord::VERSION::MAJOR < 7 && klass.connection.adapter_name == ActiveRecord::ConnectionAdapters::PostgreSQLAdapter::ADAPTER_NAME
+      end
+
+      def bulk_insert(attributes, on_duplicate: nil, unique_by: nil)
+        raise ArgumentError, "Values must not be empty" if attributes.empty?
+
+        keys = attributes.first.keys + klass.all_timestamp_attributes_in_model
+
+        current_time = klass.current_time_from_proper_timezone
+        data = attributes.map { |attr| attr.values + [current_time, current_time] }
+
+        columns = columns_for_attributes(keys)
+
+        fields_str = quote_column_names(columns)
+        values_str = quote_many_records(columns, data)
+
+        sql = <<~SQL
+          INSERT INTO #{klass.quoted_table_name}
+          (#{fields_str})
+          VALUES #{values_str}
+        SQL
+
+        if unique_by.present?
+          index = unique_indexes.find { |i| i.name.to_sym == unique_by }
+          columns = columns_for_attributes(index.columns)
+          fields = quote_column_names(columns)
+
+          sql << " ON CONFLICT (#{fields})"
+        end
+
+        if on_duplicate.present?
+          sql << " DO UPDATE SET #{on_duplicate}"
+        end
+
+        sql << " RETURNING \"id\""
+
+        klass.connection.exec_query(sql)
+      end
+
+      private
+
+      def unique_indexes
+        klass.connection.schema_cache.indexes(klass.table_name).select(&:unique)
+      end
+
+      def columns_for_attributes(attributes)
+        attributes.map do |attribute|
+          klass.column_for_attribute(attribute)
+        end
+      end
+
+      def quote_column_names(columns, table_name: false)
+        columns.map do |column|
+          column_name = klass.connection.quote_column_name(column.name)
+          if table_name
+            "#{klass.quoted_table_name}.#{column_name}"
+          else
+            column_name
+          end
+        end.join(",")
+      end
+
+      def quote_record(columns, record_values)
+        values_str = record_values.each_with_index.map do |value, i|
+          type = klass.connection.lookup_cast_type_from_column(columns[i])
+          klass.connection.quote(type.serialize(value))
+        end.join(",")
+        "(#{values_str})"
+      end
+
+      def quote_many_records(columns, data)
+        data.map { |values| quote_record(columns, values) }.join(",")
+      end
+    end
+  end
+end

data/lib/activerecord_slotted_counters/adapters/rails_upsert.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module ActiveRecordSlottedCounters
+  module Adapters
+    class RailsUpsert
+      attr_reader :klass
+
+      def initialize(klass)
+        @klass = klass
+      end
+
+      def apply?
+        ActiveRecord::VERSION::MAJOR >= 7
+      end
+
+      def bulk_insert(attributes, on_duplicate: nil, unique_by: nil)
+        klass.upsert_all(attributes, on_duplicate: on_duplicate, unique_by: unique_by)
+      end
+    end
+  end
+end

data/lib/activerecord_slotted_counters/has_slotted_counter.rb

@@ -3,10 +3,56 @@
 require "active_support"
 require "activerecord_slotted_counters/utils"
 
+require "activerecord_slotted_counters/adapters/rails_upsert"
+require "activerecord_slotted_counters/adapters/pg_upsert"
+
 module ActiveRecordSlottedCounters
   class SlottedCounter < ::ActiveRecord::Base
-    scope :associated_records, ->(counter_name, id, klass) do
-      where(counter_name: counter_name, associated_record_id: id, associated_record_type: klass)
+    class NotSupportedAdapter < StandardError
+      def initialize(adapter)
+        @adapter = adapter
+      end
+
+      def message
+        "The adapter not implemented yet (Rails #{ActiveRecord::VERSION::MAJOR}, #{@adapter})"
+      end
+    end
+
+    scope :associated_records, ->(counter_name, klass) do
+      where(counter_name: counter_name, associated_record_type: klass)
+    end
+
+    class << self
+      def bulk_insert(attributes)
+        on_duplicate_clause = "count = slotted_counters.count + excluded.count"
+
+        slotted_counter_db_adapter.bulk_insert(
+          attributes,
+          on_duplicate: Arel.sql(on_duplicate_clause),
+          unique_by: :index_slotted_counters
+        )
+      end
+
+      private
+
+      def slotted_counter_db_adapter
+        @slotted_counter_association_name ||= set_slotted_counter_db_adapter
+      end
+
+      def set_slotted_counter_db_adapter
+        available_adapters = [
+          ActiveRecordSlottedCounters::Adapters::RailsUpsert,
+          ActiveRecordSlottedCounters::Adapters::PgUpsert
+        ]
+
+        adapter = available_adapters
+          .map { |adapter| adapter.new(self) }
+          .detect { |adapter| adapter.apply? }
+
+        raise NotSupportedAdapter.new(connection.adapter_name) if adapter.nil?
+
+        adapter
+      end
     end
   end
 
@@ -38,11 +84,31 @@ module ActiveRecordSlottedCounters
         counter_name = slotted_counter_name(counter_type)
         association_name = slotted_counter_association_name(counter_type)
 
-        has_many association_name, ->(model) { associated_records(counter_name, model.id, model.class.to_s) }, **SLOTTED_COUNTERS_ASSOCIATION_OPTIONS
+        has_many association_name, ->(model) { associated_records(counter_name, 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)
+          scope_association_name = slotted_counter_association_name(counter_type)
+          return preload(scope_association_name) if ActiveRecord::VERSION::MAJOR >= 7
+
+          scope_counter_name = slotted_counter_name(counter_type)
+          counters = ActiveRecordSlottedCounters::SlottedCounter
+            .where(
+              counter_name: scope_counter_name,
+              associated_record_id: self,
+              associated_record_type: klass.to_s
+            )
+
+          grouped_counters = counters.group_by(&:associated_record_id)
+
+          each do |record|
+            assoc = record.association(scope_association_name)
+            assoc.target = grouped_counters[record.id] || []
+            assoc.loaded!
+          end
+
+          define_singleton_method(:find_each, method(:each))
+
+          self
         end
 
         _slotted_counters << counter_type
@@ -138,13 +204,8 @@ module ActiveRecordSlottedCounters
 
       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 = ActiveRecordSlottedCounters::SlottedCounter.bulk_insert(counters_params)
 
         result.rows.count
       end
@@ -191,16 +252,8 @@ module ActiveRecordSlottedCounters
 
     def read_slotted_counter(counter_type)
       association_name = slotted_counter_association_name(counter_type)
-
-      if association_cached?(association_name)
-        scope = association(association_name).scope
-        counter = scope.sum(&:count)
-
-        return counter
-      end
-
-      scope = send(association_name)
-      scope.sum(:count)
+      scope = association(association_name).load_target
+      scope.sum(&:count)
     end
   end
 end

data/lib/activerecord_slotted_counters/version.rb

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

metadata

@@ -1,15 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-slotted_counters
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.3
 platform: ruby
 authors:
 - Egor Lukin
 - Vladimir Dementyev
-autorequire:
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-01-17 00:00:00.000000000 Z
+date: 2023-04-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -95,6 +95,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec-sqlimit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Active Record slotted counters support
 email:
 - dementiev.vm@gmail.com
@@ -106,6 +120,8 @@ files:
 - LICENSE.txt
 - README.md
 - lib/activerecord-slotted_counters.rb
+- lib/activerecord_slotted_counters/adapters/pg_upsert.rb
+- lib/activerecord_slotted_counters/adapters/rails_upsert.rb
 - lib/activerecord_slotted_counters/has_slotted_counter.rb
 - lib/activerecord_slotted_counters/railtie.rb
 - lib/activerecord_slotted_counters/utils.rb
@@ -121,7 +137,7 @@ metadata:
   documentation_uri: http://github.com/evilmartians/activerecord-slotted_counters
   homepage_uri: http://github.com/evilmartians/activerecord-slotted_counters
   source_code_uri: http://github.com/evilmartians/activerecord-slotted_counters
-post_install_message:
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -136,8 +152,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.11
-signing_key:
+rubygems_version: 3.3.3
+signing_key: 
 specification_version: 4
 summary: Active Record slotted counters support
 test_files: []