activerecord-slotted_counters 0.1.4 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: efdd024fe0a5944a7cbcaa4e6990a05b74b80634affb59d3c0a30a0a3b08c52e
-  data.tar.gz: 70e2607be4d82c909002d01856d76b6663307b1ccd1204015db6e160a33c6193
+  metadata.gz: 2a233ed9bbeebe36d70a84c813b01d07cf74057709b907d491ac71e688bfc44c
+  data.tar.gz: c93306db04ae60233c9fb0ec6b8a28f1ee75f5bf22e34f503ae462f6858baa07
 SHA512:
-  metadata.gz: 5b5a4570082a3cf8264472ce8ccc59d50c52621323937cdfddc48cddfbbca01020e7e76f70457e98eeb5a5f32b960979f3315abafd880873788eb5ccd78e8a78
-  data.tar.gz: e221d1d149adbe60e4b7a60f76aced3a9d3f1c16f7e37950aad54ba44e9a7828a92e7a411be51bd0a91ecfe5827716e09080b491f375d0fe7f0cb18781e9981b
+  metadata.gz: ce0bb7f7cdb8fe0c48de169c2e8e94d5977e74cb3840bc4aafbaf181a866e12eb7b06d4ffef603d0768d21ec4b16f7092f2884dd0c1bf1b76d99cd61e71c9353
+  data.tar.gz: 93d093f88f9cae152096dbc7c3e906f4a9c39a2e50db21befeef4b9ab756515bea3149ffa6fdf7391aa2dc16d2e816f9a0819567d25992f517936b872391c135

data/CHANGELOG.md

@@ -2,6 +2,16 @@
 
 ## master
 
+## 0.3.0 (2025-03-05)
+
+- Rails 8 support. ([@palkan][])
+
+## 0.2.0 (2023-10-27)
+
+- Add Mysql support [#18](https://github.com/evilmartians/activerecord-slotted_counters/pull/18) ([@prog-supdex][])
+
+- Add SQLite support [#17](https://github.com/evilmartians/activerecord-slotted_counters/pull/17) ([@prog-supdex][])
+
 ## 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][])
@@ -25,3 +35,4 @@
 [@palkan]: https://github.com/palkan
 [@LukinEgor]: https://github.com/LukinEgor
 [@danielwestendorf]: https://github.com/danielwestendorf
+[@prog-supdex]: https://github.com/prog-supdex

data/README.md

@@ -22,9 +22,10 @@ Add to your project:
 gem "activerecord-slotted_counters"
 ```
 
-### Supported Ruby versions
+### Requirements
 
-- Ruby (MRI) >= 2.7.0
+- Ruby >= 2.7.0
+- Rails 6+
 
 ## Usage
 
@@ -67,7 +68,7 @@ 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 convenient `#with_slotted_counters` method:
+If you want to preload counters for multiple records, you can use a convenient `#with_slotted_counters` method:
 
 ```ruby
 User.all.with_slotted_counters(:comments).find_each do
@@ -77,10 +78,6 @@ end
 
 Using `counter_cache: true` on `belongs_to` associations also works as expected.
 
-## Limitations / TODO
-
-- Gem supports only PostgreSQL for Rails 6
-
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at [https://github.com/evilmartians/activerecord-slotted_counters](https://github.com/evilmartians/activerecord-slotted_counters).

data/lib/activerecord_slotted_counters/adapters/mysql_upsert.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module ActiveRecordSlottedCounters
+  module Adapters
+    class MysqlUpsert
+      attr_reader :klass
+
+      def initialize(klass, **)
+        @klass = klass
+      end
+
+      def apply?(current_adapter_name)
+        return false unless defined?(ActiveRecord::ConnectionAdapters::Mysql2Adapter)
+
+        current_adapter_name == ActiveRecord::ConnectionAdapters::Mysql2Adapter::ADAPTER_NAME
+      end
+
+      def bulk_insert(attributes, on_duplicate: 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 on_duplicate.present?
+          sql += " ON DUPLICATE KEY UPDATE #{on_duplicate};"
+        end
+
+        # insert/update and return amount of updated rows
+        klass.connection.update(sql)
+      end
+
+      def wrap_column_name(value)
+        "VALUES(#{value})"
+      end
+
+      private
+
+      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/pg_upsert.rb

@@ -5,12 +5,15 @@ module ActiveRecordSlottedCounters
     class PgUpsert
       attr_reader :klass
 
-      def initialize(klass)
+      def initialize(klass, **)
         @klass = klass
       end
 
-      def apply?
-        ActiveRecord::VERSION::MAJOR < 7 && klass.connection.adapter_name == ActiveRecord::ConnectionAdapters::PostgreSQLAdapter::ADAPTER_NAME
+      def apply?(current_adapter_name)
+        return false if ActiveRecord::VERSION::MAJOR >= 7
+        return false unless defined?(ActiveRecord::ConnectionAdapters::PostgreSQLAdapter)
+
+        current_adapter_name == ActiveRecord::ConnectionAdapters::PostgreSQLAdapter::ADAPTER_NAME
       end
 
       def bulk_insert(attributes, on_duplicate: nil, unique_by: nil)
@@ -46,7 +49,11 @@ module ActiveRecordSlottedCounters
 
         sql += " RETURNING \"id\""
 
-        klass.connection.exec_query(sql)
+        klass.connection.exec_query(sql).rows.count
+      end
+
+      def wrap_column_name(value)
+        "EXCLUDED.#{value}"
       end
 
       private

data/lib/activerecord_slotted_counters/adapters/rails7_upsert.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module ActiveRecordSlottedCounters
+  module Adapters
+    class Rails7Upsert < RailsUpsert
+      def apply?(_)
+        ActiveRecord::VERSION::MAJOR == 7 && ActiveRecord::VERSION::MINOR < 2
+      end
+
+      def bulk_insert(attributes, on_duplicate: nil, unique_by: nil)
+        opts = {on_duplicate: on_duplicate, unique_by: unique_by}
+        opts.delete(:unique_by) unless supports_insert_conflict_target
+
+        # We have to manually call #update here to return the number of affected rows.
+        # In Rails <7.2, connection is obtained internally.
+        ActiveRecord::InsertAll.new(klass, attributes, **opts).then do |inserter|
+          inserter.send(:connection).update(inserter.send(:to_sql))
+        end
+      end
+    end
+  end
+end

data/lib/activerecord_slotted_counters/adapters/rails_upsert.rb

@@ -3,18 +3,34 @@
 module ActiveRecordSlottedCounters
   module Adapters
     class RailsUpsert
-      attr_reader :klass
+      attr_reader :klass, :supports_insert_conflict_target
 
-      def initialize(klass)
+      def initialize(klass, supports_insert_conflict_target: false)
         @klass = klass
+        @supports_insert_conflict_target = supports_insert_conflict_target
       end
 
-      def apply?
+      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)
+        opts = {on_duplicate: on_duplicate, unique_by: unique_by}
+        opts.delete(:unique_by) unless supports_insert_conflict_target
+
+        klass.with_connection do |c|
+          # We have to manually call #update here to return the number of affected rows
+          c.update(ActiveRecord::InsertAll.new(klass.all, c, attributes, **opts).send(:to_sql))
+        end
+      end
+
+      def wrap_column_name(value)
+        # This is mysql
+        if !supports_insert_conflict_target
+          "VALUES(#{value})"
+        else
+          "EXCLUDED.#{value}"
+        end
       end
     end
   end

data/lib/activerecord_slotted_counters/adapters/sqlite_upsert.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module ActiveRecordSlottedCounters
+  module Adapters
+    class SqliteUpsert
+      attr_reader :klass
+
+      def initialize(klass, **)
+        @klass = klass
+      end
+
+      def apply?(current_adapter_name)
+        return false if ActiveRecord::VERSION::MAJOR >= 7
+        return false unless defined?(ActiveRecord::ConnectionAdapters::SQLite3Adapter)
+
+        current_adapter_name == ActiveRecord::ConnectionAdapters::SQLite3Adapter::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).rows.count
+      end
+
+      def wrap_column_name(value)
+        "EXCLUDED.#{value}"
+      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
+
+      def postgresql_connection?(adapter_name)
+        return false unless defined?(ActiveRecord::ConnectionAdapters::PostgreSQLAdapter)
+
+        adapter_name == ActiveRecord::ConnectionAdapters::PostgreSQLAdapter::ADAPTER_NAME
+      end
+
+      def sqlite_connection?(adapter_name)
+        return false unless defined?(ActiveRecord::ConnectionAdapters::SQLite3Adapter)
+
+        adapter_name == ActiveRecord::ConnectionAdapters::SQLite3Adapter::ADAPTER_NAME
+      end
+    end
+  end
+end

data/lib/activerecord_slotted_counters/has_slotted_counter.rb

@@ -4,7 +4,10 @@ require "active_support"
 require "activerecord_slotted_counters/utils"
 
 require "activerecord_slotted_counters/adapters/rails_upsert"
+require "activerecord_slotted_counters/adapters/rails7_upsert"
 require "activerecord_slotted_counters/adapters/pg_upsert"
+require "activerecord_slotted_counters/adapters/sqlite_upsert"
+require "activerecord_slotted_counters/adapters/mysql_upsert"
 
 module ActiveRecordSlottedCounters
   class SlottedCounter < ::ActiveRecord::Base
@@ -24,7 +27,8 @@ module ActiveRecordSlottedCounters
 
     class << self
       def bulk_insert(attributes)
-        on_duplicate_clause = "count = slotted_counters.count + excluded.count"
+        on_duplicate_clause =
+          "count = slotted_counters.count + #{slotted_counter_db_adapter.wrap_column_name("count")}"
 
         slotted_counter_db_adapter.bulk_insert(
           attributes,
@@ -41,15 +45,20 @@ module ActiveRecordSlottedCounters
 
       def set_slotted_counter_db_adapter
         available_adapters = [
+          ActiveRecordSlottedCounters::Adapters::Rails7Upsert,
           ActiveRecordSlottedCounters::Adapters::RailsUpsert,
+          ActiveRecordSlottedCounters::Adapters::MysqlUpsert,
+          ActiveRecordSlottedCounters::Adapters::SqliteUpsert,
           ActiveRecordSlottedCounters::Adapters::PgUpsert
         ]
 
+        current_adapter_name = connection.adapter_name
+
         adapter = available_adapters
-          .map { |adapter| adapter.new(self) }
-          .detect { |adapter| adapter.apply? }
+          .map { |adapter| adapter.new(self, supports_insert_conflict_target: connection.supports_insert_conflict_target?) }
+          .detect { |adapter| adapter.apply?(current_adapter_name) }
 
-        raise NotSupportedAdapter.new(connection.adapter_name) if adapter.nil?
+        raise NotSupportedAdapter.new(current_adapter_name) if adapter.nil?
 
         adapter
       end
@@ -205,9 +214,7 @@ module ActiveRecordSlottedCounters
       def insert_counters_records(ids, counters)
         counters_params = prepare_slotted_counters_params(ids, counters)
 
-        result = ActiveRecordSlottedCounters::SlottedCounter.bulk_insert(counters_params)
-
-        result.rows.count
+        ActiveRecordSlottedCounters::SlottedCounter.bulk_insert(counters_params)
       end
 
       def remove_counters_records(ids, counter_name)
@@ -219,7 +226,7 @@ module ActiveRecordSlottedCounters
       end
 
       def touch_attributes(ids, touch)
-        scope = where(id: ids)
+        scope = unscoped.where(id: ids)
         return scope.touch_all if touch == true
 
         scope.touch_all(touch)

data/lib/activerecord_slotted_counters/utils.rb

@@ -7,11 +7,11 @@ module ActiveRecordSlottedCounters
     private
 
     def slotted_counter_association_name(counter_type)
-      "#{counter_type}_slotted_counters".to_sym
+      :"#{counter_type}_slotted_counters"
     end
 
     def slotted_counter_name(counter_type)
-      "#{counter_type}_count".to_sym
+      :"#{counter_type}_count"
     end
 
     # TODO refactoring

data/lib/activerecord_slotted_counters/version.rb

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

metadata

@@ -1,15 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-slotted_counters
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.3.0
 platform: ruby
 authors:
 - Egor Lukin
 - Vladimir Dementyev
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-04-20 00:00:00.000000000 Z
+date: 2025-03-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -67,34 +67,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '3.9'
-- !ruby/object:Gem::Dependency
-  name: pg
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '1.4'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '1.4'
-- !ruby/object:Gem::Dependency
-  name: sqlite3
-  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'
 - !ruby/object:Gem::Dependency
   name: rspec-sqlimit
   requirement: !ruby/object:Gem::Requirement
@@ -120,8 +92,11 @@ files:
 - LICENSE.txt
 - README.md
 - lib/activerecord-slotted_counters.rb
+- lib/activerecord_slotted_counters/adapters/mysql_upsert.rb
 - lib/activerecord_slotted_counters/adapters/pg_upsert.rb
+- lib/activerecord_slotted_counters/adapters/rails7_upsert.rb
 - lib/activerecord_slotted_counters/adapters/rails_upsert.rb
+- lib/activerecord_slotted_counters/adapters/sqlite_upsert.rb
 - lib/activerecord_slotted_counters/has_slotted_counter.rb
 - lib/activerecord_slotted_counters/railtie.rb
 - lib/activerecord_slotted_counters/utils.rb
@@ -137,7 +112,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
@@ -152,8 +127,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.3
-signing_key: 
+rubygems_version: 3.4.19
+signing_key:
 specification_version: 4
 summary: Active Record slotted counters support
 test_files: []