activerecord-slotted_counters 0.1.4 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: efdd024fe0a5944a7cbcaa4e6990a05b74b80634affb59d3c0a30a0a3b08c52e
-  data.tar.gz: 70e2607be4d82c909002d01856d76b6663307b1ccd1204015db6e160a33c6193
+  metadata.gz: 76c73b0a3e75e1fbddb355beedf5aa5967f43ffb5043d0051572423ef3a2188c
+  data.tar.gz: be40038645de42ee29e31c02cdafac846641d079404c65ac12a44726d22dc8fa
 SHA512:
-  metadata.gz: 5b5a4570082a3cf8264472ce8ccc59d50c52621323937cdfddc48cddfbbca01020e7e76f70457e98eeb5a5f32b960979f3315abafd880873788eb5ccd78e8a78
-  data.tar.gz: e221d1d149adbe60e4b7a60f76aced3a9d3f1c16f7e37950aad54ba44e9a7828a92e7a411be51bd0a91ecfe5827716e09080b491f375d0fe7f0cb18781e9981b
+  metadata.gz: e5f7a7077bb02f35124a72417a2d60d2ea8da356a32e12020549fbacdb08d7ea76f2ff913e4fdd79376ab334cfec15221e808e62a76bc2652e779c31a9462ef7
+  data.tar.gz: a8f3881d903bbb5f032bc8763733d5f3abd770c44a9796cfbec79db171fcb1f0a453d4fe0124907315c662161d3c33a523fd20557fc2419a6c3b3c270323e71b

data/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 ## master
 
+## 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 +31,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

@@ -9,8 +9,11 @@ module ActiveRecordSlottedCounters
         @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/rails_upsert.rb

@@ -9,12 +9,16 @@ module ActiveRecordSlottedCounters
         @klass = klass
       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)
+        klass.upsert_all(attributes, on_duplicate: on_duplicate, unique_by: unique_by).rows.count
+      end
+
+      def wrap_column_name(value)
+        "EXCLUDED.#{value}"
       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

@@ -5,6 +5,8 @@ require "activerecord_slotted_counters/utils"
 
 require "activerecord_slotted_counters/adapters/rails_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 +26,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 +44,19 @@ module ActiveRecordSlottedCounters
 
       def set_slotted_counter_db_adapter
         available_adapters = [
-          ActiveRecordSlottedCounters::Adapters::RailsUpsert,
-          ActiveRecordSlottedCounters::Adapters::PgUpsert
+          ActiveRecordSlottedCounters::Adapters::MysqlUpsert,
+          ActiveRecordSlottedCounters::Adapters::SqliteUpsert,
+          ActiveRecordSlottedCounters::Adapters::PgUpsert,
+          ActiveRecordSlottedCounters::Adapters::RailsUpsert
         ]
 
+        current_adapter_name = connection.adapter_name
+
         adapter = available_adapters
           .map { |adapter| adapter.new(self) }
-          .detect { |adapter| adapter.apply? }
+          .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 +212,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)

data/lib/activerecord_slotted_counters/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ActiveRecordSlottedCounters # :nodoc:
-  VERSION = "0.1.4"
+  VERSION = "0.2.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.2.0
 platform: ruby
 authors:
 - Egor Lukin
 - Vladimir Dementyev
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-04-20 00:00:00.000000000 Z
+date: 2023-10-27 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,10 @@ 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/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 +111,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 +126,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.20
+signing_key:
 specification_version: 4
 summary: Active Record slotted counters support
 test_files: []