activerecord-slotted_counters 0.1.2 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 94aead1f1be073e3dbf7548257d6db2b8eda15be09f2c199b6b3cdbf9b6ba0f3
-  data.tar.gz: ac2e1b977ab04501cd1139bd1d410b9f58b0b9395add905b1034eebb54fe4c86
+  metadata.gz: bdd6573e6f4d045624e5d0e068f40728ece0ff47461b0c476606689b74de6c7d
+  data.tar.gz: 79fc88a8fd00ff709b34b9cfd192a9275b95647639281ee36f10e2b61b5eb79a
 SHA512:
-  metadata.gz: ba74654e981dbc83043dc295296939e85053b2c7c8543ca3472d2f659523b9a3ea5be60ac15a87a492f7fa3758defac451382ff518a96f4feee573eb0f68ed26
-  data.tar.gz: 857ec7de346c584b1fcdd79bcb81becb7ecec9bb86b2087a8acf83d25ed13b55d25883439b6242b3f26bd726cc592897930ff9f1755c720b7aca41ed55d91503
+  metadata.gz: d2fdb9401b2473f9d1ea8048bc14056665a310fe52fb4c0e1572b989ddab04f4907fa15df57821f7792b8861bd1d07259da9ddef425281c423c68d37e922ebbe
+  data.tar.gz: 5e399bc56136750d40f5303677ce381ae791a56a96f52ac2df9b1c6f7ca6443c4eaef2cad71b631231d043023f1e6a1a8643f54bb607afd68c73462cdafc25db

data/CHANGELOG.md

@@ -2,6 +2,10 @@
 
 ## 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][])

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,11 +3,57 @@
 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
+    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
 
   module BelongsToAssociation
@@ -41,8 +87,28 @@ module ActiveRecordSlottedCounters
         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

data/lib/activerecord_slotted_counters/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-slotted_counters
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.3
 platform: ruby
 authors:
 - Egor Lukin
@@ -120,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