acts_as_shardable 0.7.0 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 11ce4ec7bf911d8b8eb80a615a3dc81a229f93b1
-  data.tar.gz: 1cd6cc539c4bb61e219e6d7e402b8accc75306ac
+SHA256:
+  metadata.gz: f0eac1d75f9a6c51a14d30662973d19a2eb191c2b02aae5cfbe2fd0564dc45d2
+  data.tar.gz: 501940171fa843435ce04ba2240f305fea243d738d1513b737e69d3292536035
 SHA512:
-  metadata.gz: dea62a56bb346fe1616ca09af42773fec5fdf871b74371dcedfe7ed974d7e29f94a20981fa97bfd5c0778fe18e58d62a547a59c9a21ef0be11e335dab7692cd0
-  data.tar.gz: 7b1798568e693b7dcf7d05e723df46b1b641a3892570418a531bf18b488b5c2eeebecb9044d6e9726be5b04109eb4eb680b0c0d0b9f788d07654be24c46aad34
+  metadata.gz: 3c5fc8e35e934d3fbd2aefcbdc24c8715bf9e13b25c98500ccd1eb7ec7b1a4aa62743b0381f67c7e2f10585dabd91de9b58f537a3ea2c0b70c1e7faa5e083c51
+  data.tar.gz: bd35953eb6fff25b02757df5948e6995aa2374b72062293708fd418d79ef44e9ff91295519e912f67b6eff010106b29927f3ed03b06940136efa26c250c5d175

data/README.md

@@ -18,17 +18,25 @@ Or install it yourself as:
 
 ## Usage
 
-Example
+Examples
 
-In your model:
+### Built-in sharding method(mod)
 
 ```ruby
 class Mod2Model < ActiveRecord::Base
-  acts_as_shardable by: :hash_id, mod: 2
+  acts_as_shardable by: :hash_id, using: :mod, args: { mod: 2 }
 end
 ```
 
-and migrations:
+### Customized sharding method
+
+```ruby
+class Mod2Model < ActiveRecord::Base
+  acts_as_shardable by: :hash_id, using: ->(hash_id) { hash_id % 2 }
+end
+```
+
+### Migrations
 
 ```ruby
 class CreateMod2Models < ActiveRecord::Migration

data/lib/acts_as_shardable.rb

@@ -1,5 +1,7 @@
 require 'active_record'
 require "acts_as_shardable/version"
+require "acts_as_shardable/attribute_methods"
+require "acts_as_shardable/shard"
 
 module ActsAsShardable
 
@@ -10,207 +12,30 @@ module ActsAsShardable
     Mutex.new
   end
 
-  def acts_as_shardable(by:, mod:)
-    class_attribute :shard_method, :shard_mod, :module_name, :base_table_name
+  def acts_as_shardable(by:, using:, args: {})
+    class_attribute :shard_method, :shard_method_using, :shard_args, :module_name, :base_table_name
+
+    case using
+    when Symbol
+      # built-in functions
+    when Proc
+      # customized functions
+    else
+      raise ArgumentError, "unknown sharding function, `using` must be a symbol or proc"
+    end
 
     mutex.synchronize do
       self.shard_method = by
-      self.shard_mod = mod
+      self.shard_method_using = using
+      self.shard_args = args
       self.module_name = self.name.deconstantize.safe_constantize || Object
       self.base_table_name = self.name.demodulize.pluralize.underscore
       self.table_name = "#{self.base_table_name}_0000"
       self.validates self.shard_method.to_sym, presence: true
-
-      # Updates the associated record with values matching those of the instance attributes.
-      # Returns the number of affected rows.
-      define_method :_update_record do |attribute_names = self.attribute_names|
-        attribute_names = keys_for_partial_write if self.class.base_class.partial_writes
-
-        was, is = changes[self.class.base_class.shard_method]
-
-        if was
-          # shard_column changed
-          table_was = self.class.base_class.sharding(was).table_name
-          table_is = self.class.base_class.sharding(is).table_name
-          raise WrongShardingError, "Please move from #{table_was} to #{table_is} manually."
-        else
-          # shard_column not changing
-          if locking_enabled?
-            lock_col = self.class.base_class.locking_column
-            previous_lock_value = read_attribute(lock_col)
-            self[lock_col] = previous_lock_value + 1
-
-            attribute_names += [lock_col].compact
-            attribute_names.uniq!
-
-            begin
-              relation = shard.unscoped
-
-              affected_rows = relation.where(
-                  self.class.primary_key => id,
-                  lock_col => previous_lock_value,
-              ).update_all(
-                  Hash[attributes_for_update(attribute_names).map do |name|
-                    [name, _read_attribute(name)]
-                  end]
-              )
-
-              unless affected_rows == 1
-                raise ActiveRecord::StaleObjectError.new(self, "update")
-              end
-
-              affected_rows
-
-                # If something went wrong, revert the version.
-            rescue Exception
-              send(lock_col + '=', previous_lock_value)
-              raise
-            end
-          else
-            if self.respond_to?(:attributes_with_values_for_update, true)
-              attributes_values = attributes_with_values_for_update(attribute_names)
-            else
-              attribute_names = attributes_for_update(attribute_names)
-              attributes_values = {}
-              arel_table = shard.arel_table
-
-              attribute_names.each do |name|
-                attributes_values[arel_table[name]] = typecasted_attribute_value(name)
-              end
-            end
-
-            if attributes_values.empty?
-              0
-            else
-              if ActiveRecord::VERSION::MAJOR == 5 && ActiveRecord::VERSION::MINOR >= 1
-                shard.unscoped._update_record(attributes_values, self.class.base_class.primary_key => id_in_database)
-              else
-                shard.unscoped._update_record(attributes_values, id, id_was)
-              end
-            end
-          end
-        end
-      end
-
-      private :_update_record
-
-
-      define_method :touch do |*names|
-        raise ActiveRecordError, "cannot touch on a new record object" unless persisted?
-
-        attributes = timestamp_attributes_for_update_in_model
-        attributes.concat(names)
-
-        unless attributes.empty?
-          current_time = current_time_from_proper_timezone
-          changes = {}
-
-          attributes.each do |column|
-            column = column.to_s
-            changes[column] = write_attribute(column, current_time)
-          end
-
-          if locking_enabled?
-            if self.respond_to?(:increment_lock)
-              changes[self.class.base_class.locking_column] = increment_lock
-            else
-              lock_col = self.class.base_class.locking_column
-              previous_lock_value = read_attribute(lock_col)
-              self[lock_col] = previous_lock_value + 1
-              changes[lock_col] = self[lock_col]
-            end
-          end
-
-          clear_attribute_changes(changes.keys)
-          primary_key = self.class.primary_key
-          shard.unscoped.where(primary_key => self[primary_key]).update_all(changes) == 1
-        else
-          true
-        end
-      end
-
-      # Creates a record with values matching those of the instance attributes
-      # and returns its id.
-      define_method :_create_record do |attribute_names = self.attribute_names|
-        _run_create_callbacks {
-          attribute_names = keys_for_partial_write if self.class.base_class.partial_writes
-          attribute_names |= [self.class.base_class.locking_column] if locking_enabled?
-
-          if self.respond_to?(:attributes_with_values_for_create, true)
-            attributes_values = attributes_with_values_for_create(attribute_names)
-          else
-            attributes_values = arel_attributes_with_values_for_create(attribute_names)
-          end
-
-          if shard.respond_to?(:_insert_record)
-            new_id = shard.unscoped._insert_record attributes_values
-          else
-            new_id = shard.unscoped.insert attributes_values
-          end
-
-          self.id ||= new_id if self.class.base_class.primary_key
-
-          @new_record = false
-          id
-        }
-      end
-
-      private :_create_record
-
-      define_method :shard do
-        shard_value = self.send(self.class.base_class.shard_method)
-        self.class.base_class.sharding(shard_value)
-      end
-
-      private :shard
-
-      self.class.send :define_method, :sharding do |column|
-        i = column.to_i % shard_mod
-        klass = "#{base_class.name.demodulize}_%04d" % i
-        @@sharding_class ||= {}
-        @@sharding_class[klass] ||= mutex.synchronize do
-          if module_name.const_defined?(klass, false)
-            module_name.const_get(klass, false)
-          else
-            Class.new(base_class) do
-              self.table_name = ("#{base_class.base_table_name}_%04d" % i)
-
-              if base_class.respond_to?(:protobuf_message)
-                self.protobuf_message base_class.protobuf_message
-
-                # Create a .to_proto method on XXX::ActiveRecord_Relation
-                self.const_get('ActiveRecord_Relation', false).class_exec do
-                  def to_proto(*args)
-                    msg_class = base_class.name.demodulize.pluralize
-                    module_name = base_class.name.deconstantize.constantize
-                    module_name::Messages.const_get(msg_class, false).new(msg_class.underscore => map { |r| r.to_proto(*args) })
-                  end
-                end
-              end
-
-            end.tap { |k| module_name.const_set(klass, k) }
-          end
-        end
-      end
-
-      define_method :reload do |options = nil|
-        clear_aggregation_cache
-        clear_association_cache
-        shard.connection.clear_query_cache
-
-        fresh_object =
-            if options && options[:lock]
-              shard.unscoped { shard.lock(options[:lock]).find(id) }
-            else
-              shard.unscoped { shard.find(id) }
-            end
-
-        @attributes = fresh_object.instance_variable_get('@attributes')
-        @new_record = false
-        fresh_object
-      end
     end
 
+    include AttributeMethods
+    include Shard
   end
 
 end

data/lib/acts_as_shardable/attribute_methods.rb

@@ -0,0 +1,14 @@
+module ActsAsShardable
+  module AttributeMethods
+    private
+
+    # @overload
+    def _assign_attribute(k, v)
+      if persisted? && k.to_s == self.class.base_class.shard_method.to_s
+        raise WrongShardingError, "The sharding key #{k} can't be change"
+      end
+
+      super
+    end
+  end
+end

data/lib/acts_as_shardable/shard.rb

@@ -0,0 +1,72 @@
+module ActsAsShardable
+  module Shard
+    extend ActiveSupport::Concern
+
+    included do
+      alias :_class :class
+
+      def shard
+        if defined? @attributes
+          shard_value = self.attributes[_class.base_class.shard_method.to_s]
+          if shard_value
+            _class.base_class.sharding(shard_value)
+          else
+            _class
+          end
+        else
+          _class
+        end
+      end
+
+      alias :class :shard
+    end
+
+    class_methods do
+
+      def sharding(column)
+        i = case self.shard_method_using
+            when Proc
+              self.shard_method_using.call(column)
+            when Symbol
+              self.send(self.shard_method_using, column, self.shard_args)
+            end
+
+        constantize_class(i)
+      end
+
+      private
+
+      def mod(current, mod:)
+        current % mod
+      end
+
+      def constantize_class(i)
+        class_name = "#{base_class.name.demodulize}_%04d" % i
+        @@sharding_class ||= {}
+        @@sharding_class[class_name] ||= mutex.synchronize do
+          if module_name.const_defined?(class_name, false)
+            module_name.const_get(class_name, false)
+          else
+            Class.new(base_class) do
+              self.table_name = ("#{base_class.base_table_name}_%04d" % i)
+
+              if base_class.respond_to?(:protobuf_message)
+                self.protobuf_message base_class.protobuf_message
+
+                # Create a .to_proto method on XXX::ActiveRecord_Relation
+                self.const_get('ActiveRecord_Relation', false).class_exec do
+                  def to_proto(*args)
+                    msg_class = base_class.name.demodulize.pluralize
+                    module_name = base_class.name.deconstantize.constantize
+                    module_name::Messages.const_get(msg_class, false).new(msg_class.underscore => map { |r| r.to_proto(*args) })
+                  end
+                end
+              end
+
+            end.tap { |k| module_name.const_set(class_name, k) }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/acts_as_shardable/version.rb

@@ -1,3 +1,3 @@
 module ActsAsShardable
-  VERSION = "0.7.0"
+  VERSION = "0.8.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: acts_as_shardable
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.8.0
 platform: ruby
 authors:
 - scorix
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-05-17 00:00:00.000000000 Z
+date: 2019-09-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -97,6 +97,8 @@ files:
 - bin/console
 - bin/setup
 - lib/acts_as_shardable.rb
+- lib/acts_as_shardable/attribute_methods.rb
+- lib/acts_as_shardable/shard.rb
 - lib/acts_as_shardable/version.rb
 homepage: https://github.com/scorix
 licenses:
@@ -119,7 +121,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.11
+rubygems_version: 2.7.3
 signing_key: 
 specification_version: 4
 summary: Let subclasses of ActiveRecord::Base to be shardable.