activerecord-slotted_counters 0.1.2 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 94aead1f1be073e3dbf7548257d6db2b8eda15be09f2c199b6b3cdbf9b6ba0f3
-  data.tar.gz: ac2e1b977ab04501cd1139bd1d410b9f58b0b9395add905b1034eebb54fe4c86
+  metadata.gz: efdd024fe0a5944a7cbcaa4e6990a05b74b80634affb59d3c0a30a0a3b08c52e
+  data.tar.gz: 70e2607be4d82c909002d01856d76b6663307b1ccd1204015db6e160a33c6193
 SHA512:
-  metadata.gz: ba74654e981dbc83043dc295296939e85053b2c7c8543ca3472d2f659523b9a3ea5be60ac15a87a492f7fa3758defac451382ff518a96f4feee573eb0f68ed26
-  data.tar.gz: 857ec7de346c584b1fcdd79bcb81becb7ecec9bb86b2087a8acf83d25ed13b55d25883439b6242b3f26bd726cc592897930ff9f1755c720b7aca41ed55d91503
+  metadata.gz: 5b5a4570082a3cf8264472ce8ccc59d50c52621323937cdfddc48cddfbbca01020e7e76f70457e98eeb5a5f32b960979f3315abafd880873788eb5ccd78e8a78
+  data.tar.gz: e221d1d149adbe60e4b7a60f76aced3a9d3f1c16f7e37950aad54ba44e9a7828a92e7a411be51bd0a91ecfe5827716e09080b491f375d0fe7f0cb18781e9981b

data/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 ## master
 
+## 0.1.4 (2023-04-19)
+
+- Fix "can't modify frozen String" for the pg adapter (ruby 2.7)  [#15](https://github.com/evilmartians/activerecord-slotted_counters/pull/15) ([@LukinEgor][])
+
+## 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.4"
 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.4
 platform: ruby
 authors:
 - Egor Lukin
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-04-19 00:00:00.000000000 Z
+date: 2023-04-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -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