switchman 3.3.1 → 4.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d0330d210ee4f44c8ceb3b66ba1536f5538c4a1efcd4a939d492ffa65602fca7
-  data.tar.gz: '0787f10b30acc34e0a5e48423c524d2db27b8b92dabd76bf567fb6631c0587c3'
+  metadata.gz: e03940e1a5f3d0e7b933d99b3cbd68e3998b55f14ac0e7eec91ef81a193445e1
+  data.tar.gz: 923793689418332ab6ce2ffef2981567bd74b6358916794d958172638b0ec160
 SHA512:
-  metadata.gz: 65e0cbb8c9015940209145aa229648fa763d999399053e9046b0b4a60e1aae1ebfe419983776364e7e2460ca2e0cc0021188d286a8da6a9d9c0a74bd59d1bbc2
-  data.tar.gz: db938a240af2ffb146453536d42db25d38ac13ca136b757d219fef46cf99476c0916beb65c8e06e2bc48067b94736d8f88b4c13519f85d99ec2b07fc423eccc9
+  metadata.gz: 6950ac12cf6532f98e3674ded8890e7bb2f9ef50f33657220096de50508715ab047250c163546dc7396c61d15197ee2b517ae342f84cbe007ae22a217ed7751f
+  data.tar.gz: c45df067998ec5868bfe2c6a0f52608ffd9de9a19e2ce55ba55fc9986e077833df9964c5783c0f394a9683cb21a610e7f2a781d88e690fbc2bfeef5e8e352826

data/Rakefile

@@ -2,37 +2,38 @@
 # frozen_string_literal: true
 
 begin
-  require 'bundler/setup'
+  require "bundler/setup"
 rescue LoadError
-  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+  puts "You must `gem install bundler` and `bundle install` to run rake tasks"
 end
 begin
-  require 'rdoc/task'
+  require "rdoc/task"
 rescue LoadError
-  require 'rdoc/rdoc'
-  require 'rake/rdoctask'
+  require "rdoc/rdoc"
+  require "rake/rdoctask"
   RDoc::Task = Rake::RDocTask
 end
 
 RDoc::Task.new(:rdoc) do |rdoc|
-  rdoc.rdoc_dir = 'rdoc'
-  rdoc.title    = 'Switchman'
-  rdoc.options << '--line-numbers'
-  rdoc.rdoc_files.include('lib/**/*.rb')
+  rdoc.rdoc_dir = "rdoc"
+  rdoc.title    = "Switchman"
+  rdoc.options << "--line-numbers"
+  rdoc.rdoc_files.include("lib/**/*.rb")
 end
 
-APP_RAKEFILE = File.expand_path('spec/dummy/Rakefile', __dir__)
-load 'rails/tasks/engine.rake'
+load "./spec/tasks/coverage.rake"
+APP_RAKEFILE = File.expand_path("spec/dummy/Rakefile", __dir__)
+load "rails/tasks/engine.rake"
 
 Bundler::GemHelper.install_tasks
 
-require 'rspec/core/rake_task'
+require "rspec/core/rake_task"
 RSpec::Core::RakeTask.new
 
-require 'rubocop/rake_task'
+require "rubocop/rake_task"
 
 RuboCop::RakeTask.new do |task|
-  task.options = ['-S']
+  task.options = ["-S"]
 end
 
 task default: %i[spec]

data/db/migrate/20180828183945_add_default_shard_index.rb

@@ -5,7 +5,7 @@ class AddDefaultShardIndex < ActiveRecord::Migration[4.2]
     Switchman::Shard.where(default: nil).update_all(default: false) if Switchman::Shard.current.default?
     change_column_default :switchman_shards, :default, false
     change_column_null :switchman_shards, :default, false
-    options = if connection.adapter_name == 'PostgreSQL'
+    options = if connection.adapter_name == "PostgreSQL"
                 { unique: true, where: '"default"' }
               else
                 {}

data/db/migrate/20190114212900_add_unique_name_indexes.rb

@@ -3,9 +3,15 @@
 class AddUniqueNameIndexes < ActiveRecord::Migration[4.2]
   def change
     add_index :switchman_shards, %i[database_server_id name], unique: true
-    add_index :switchman_shards, :database_server_id, unique: true, where: 'name IS NULL',
-                                                      name: 'index_switchman_shards_unique_primary_shard'
-    add_index :switchman_shards, '(true)', unique: true, where: 'database_server_id IS NULL AND name IS NULL',
-                                           name: 'index_switchman_shards_unique_primary_db_and_shard'
+    add_index :switchman_shards,
+              :database_server_id,
+              unique: true,
+              where: "name IS NULL",
+              name: "index_switchman_shards_unique_primary_shard"
+    add_index :switchman_shards,
+              "(true)",
+              unique: true,
+              where: "database_server_id IS NULL AND name IS NULL",
+              name: "index_switchman_shards_unique_primary_db_and_shard"
   end
 end

data/lib/switchman/active_record/abstract_adapter.rb

@@ -5,7 +5,7 @@ module Switchman
     module AbstractAdapter
       module ForeignKeyCheck
         def add_column(table, name, type, limit: nil, **)
-          Switchman.foreign_key_check(name, type, limit: limit)
+          Switchman.foreign_key_check(name, type, limit:)
           super
         end
       end
@@ -27,8 +27,10 @@ module Switchman
         quote_table_name(name)
       end
 
-      def schema_migration
-        ::ActiveRecord::SchemaMigration
+      if ::Rails.version < "7.1"
+        def schema_migration
+          ::ActiveRecord::SchemaMigration
+        end
       end
 
       protected

data/lib/switchman/active_record/associations.rb

@@ -24,11 +24,23 @@ module Switchman
 
       module CollectionAssociation
         def find_target
-          shards = reflection.options[:multishard] && owner.respond_to?(:associated_shards) ? owner.associated_shards : [shard]
+          shards = if reflection.options[:multishard] && owner.respond_to?(:associated_shards)
+                     owner.associated_shards
+                   else
+                     [shard]
+                   end
           # activate both the owner and the target's shard category, so that Reflection#join_id_for,
           # when called for the owner, will be returned relative to shard the query will execute on
-          Shard.with_each_shard(shards, [klass.connection_class_for_self, owner.class.connection_class_for_self].uniq) do
-            super
+          Shard.with_each_shard(shards,
+                                [klass.connection_class_for_self, owner.class.connection_class_for_self].uniq) do
+            if reflection.options[:multishard] && owner.respond_to?(:associated_shards) && reflection.has_scope?
+              # Prevent duplicate results when reflection has a scope (when it would use the skip_statement_cache? path)
+              # otherwise, the super call will set the shard_value to the object, causing it to iterate too many times
+              # over the associated shards
+              scope.shard(Shard.current(scope.klass.connection_class_for_self), :association).to_a
+            else
+              super
+            end
           end
         end
 
@@ -50,7 +62,7 @@ module Switchman
         def shard
           if @owner.class.sharded_column?(@reflection.foreign_key) &&
              (foreign_id = @owner[@reflection.foreign_key])
-            Shard.shard_for(foreign_id, @owner.shard)
+            Shard.shard_for(foreign_id, @owner.loaded_from_shard)
           else
             super
           end
@@ -128,7 +140,12 @@ module Switchman
                 Shard.lookup(shard).activate do
                   scope_was = loader_query.scope
                   begin
-                    loader_query.instance_variable_set(:@scope, loader_query.scope.shard(Shard.current(loader_query.scope.model.connection_class_for_self)))
+                    loader_query.instance_variable_set(
+                      :@scope,
+                      loader_query.scope.shard(
+                        Shard.current(loader_query.scope.model.connection_class_for_self)
+                      )
+                    )
                     ret += loader_query.load_records_for_keys(keys) do |record|
                       loaders.each { |l| l.set_inverse(record) }
                     end
@@ -157,7 +174,7 @@ module Switchman
           end
 
           # Disabling to keep closer to rails original
-          # rubocop:disable Naming/AccessorMethodName, Style/GuardClause
+          # rubocop:disable Naming/AccessorMethodName
           # significant changes:
           #  * globalize the key to lookup
           def set_inverse(record)
@@ -174,7 +191,7 @@ module Switchman
               association.set_inverse_instance(record)
             end
           end
-          # rubocop:enable Naming/AccessorMethodName, Style/GuardClause
+          # rubocop:enable Naming/AccessorMethodName
 
           # significant changes:
           #  * partition_by_shard the records_for call
@@ -186,40 +203,7 @@ module Switchman
             # #compare_by_identity makes such owners different hash keys
             @records_by_owner = {}.compare_by_identity
 
-            if ::Rails.version >= '7.0'
-              raw_records ||= loader_query.records_for([self])
-            elsif owner_keys.empty?
-              raw_records ||= []
-            else
-              # determine the shard to search for each owner
-              if reflection.macro == :belongs_to
-                # for belongs_to, it's the shard of the foreign_key
-                partition_proc = lambda do |owner|
-                  if owner.class.sharded_column?(owner_key_name)
-                    Shard.shard_for(owner[owner_key_name], owner.shard)
-                  else
-                    Shard.current
-                  end
-                end
-              elsif !reflection.options[:multishard]
-                # for non-multishard associations, it's *just* the owner's shard
-                partition_proc = ->(owner) { owner.shard }
-              end
-
-              raw_records ||= Shard.partition_by_shard(owners, partition_proc) do |partitioned_owners|
-                relative_owner_keys = partitioned_owners.map do |owner|
-                  key = owner[owner_key_name]
-                  if key && owner.class.sharded_column?(owner_key_name)
-                    key = Shard.relative_id_for(key, owner.shard,
-                                                Shard.current(klass.connection_class_for_self))
-                  end
-                  convert_key(key)
-                end
-                relative_owner_keys.compact!
-                relative_owner_keys.uniq!
-                records_for(relative_owner_keys)
-              end
-            end
+            raw_records ||= loader_query.records_for([self])
 
             @preloaded_records = raw_records.select do |record|
               assignments = false
@@ -273,17 +257,73 @@ module Switchman
       end
 
       module AutosaveAssociation
-        def record_changed?(reflection, record, key)
-          record.new_record? ||
-            (record.has_attribute?(reflection.foreign_key) && record.send(reflection.foreign_key) != key) || # have to use send instead of [] because sharding
-            record.attribute_changed?(reflection.foreign_key)
-        end
+        if ::Rails.version < "7.1"
+          def association_foreign_key_changed?(reflection, record, key)
+            return false if reflection.through_reflection?
+
+            # have to use send instead of _read_attribute because sharding
+            record.has_attribute?(reflection.foreign_key) && record.send(reflection.foreign_key) != key
+          end
 
-        def save_belongs_to_association(reflection)
-          # this seems counter-intuitive, but the autosave code will assign to attribute bypassing switchman,
-          # after reading the id attribute _without_ bypassing switchman. So we need Shard.current for the
-          # category of the associated record to match Shard.current for the category of self
-          shard.activate(connection_class_for_self_for_reflection(reflection)) { super }
+          def save_belongs_to_association(reflection)
+            # this seems counter-intuitive, but the autosave code will assign to attribute bypassing switchman,
+            # after reading the id attribute _without_ bypassing switchman. So we need Shard.current for the
+            # category of the associated record to match Shard.current for the category of self
+            shard.activate(connection_class_for_self_for_reflection(reflection)) { super }
+          end
+        else
+          def association_foreign_key_changed?(reflection, record, key)
+            return false if reflection.through_reflection?
+
+            foreign_key = Array(reflection.foreign_key)
+            return false unless foreign_key.all? { |k| record._has_attribute?(k) }
+
+            # have to use send instead of _read_attribute because sharding
+            foreign_key.map { |k| record.send(k) } != Array(key)
+          end
+
+          def save_belongs_to_association(reflection)
+            association = association_instance_get(reflection.name)
+            return unless association&.loaded? && !association.stale_target?
+
+            record = association.load_target
+            return unless record && !record.destroyed?
+
+            autosave = reflection.options[:autosave]
+
+            if autosave && record.marked_for_destruction?
+              foreign_key = Array(reflection.foreign_key)
+              foreign_key.each { |key| self[key] = nil }
+              record.destroy
+            elsif autosave != false
+              if record.new_record? || (autosave && record.changed_for_autosave?)
+                saved = record.save(validate: !autosave)
+              end
+
+              if association.updated?
+                primary_key = Array(compute_primary_key(reflection, record)).map(&:to_s)
+                foreign_key = Array(reflection.foreign_key)
+
+                primary_key_foreign_key_pairs = primary_key.zip(foreign_key)
+                primary_key_foreign_key_pairs.each do |pk, fk|
+                  # Notable change: add relative_id_for here
+                  association_id = if record.class.sharded_column?(pk)
+                                     Shard.relative_id_for(
+                                       record._read_attribute(pk),
+                                       record.shard,
+                                       shard
+                                     )
+                                   else
+                                     record._read_attribute(pk)
+                                   end
+                  self[fk] = association_id unless self[fk] == association_id
+                end
+                association.loaded!
+              end
+
+              saved if autosave
+            end
+          end
         end
       end
     end

data/lib/switchman/active_record/attribute_methods.rb

@@ -26,13 +26,22 @@ module Switchman
         end
 
         def define_attribute_methods
-          super
+          result = super
           # ensure that we're using the sharded attribute method
           # and not the silly one in AR::AttributeMethods::PrimaryKey
-          return unless sharded_column?(@primary_key)
-
-          class_eval(build_sharded_getter('id', '_read_attribute(@primary_key)', "::#{connection_class_for_self.name}"), __FILE__, __LINE__)
-          class_eval(build_sharded_setter('id', @primary_key, "::#{connection_class_for_self.name}"), __FILE__, __LINE__)
+          return result unless sharded_column?(@primary_key)
+
+          class_eval(
+            build_sharded_getter("id",
+                                 "_read_attribute(@primary_key)",
+                                 "::#{connection_class_for_self.name}"),
+            __FILE__,
+            __LINE__
+          )
+          class_eval(build_sharded_setter("id", @primary_key, "::#{connection_class_for_self.name}"),
+                     __FILE__,
+                     __LINE__)
+          result
         end
 
         protected
@@ -46,20 +55,22 @@ module Switchman
           raise if connection.open_transactions.positive?
         end
 
-        # rubocop:disable Naming/MethodParameterName
         def define_cached_method(owner, name, namespace:, as:, &block)
-          if ::Rails.version < '7.0'
-            yield owner
-            owner.rename_method(as, name)
+          if ::Rails.version < "7.1.4"
+            # https://github.com/rails/rails/commit/a2a12fc2e3f4e6d06f81d4c74c88f8e6b3369ee6#diff-5b59ece6d9396b596f06271cec0ea726e3360911383511c49b1a66f454bfc2b6L30
+            # These arguments were effectively swapped in Rails 7.1.4, so previous versions need them reversed
+            owner.define_cached_method(as, namespace:, as: name, &block)
           else
-            owner.define_cached_method(name, namespace: namespace, as: as, &block)
+            owner.define_cached_method(name, namespace:, as:, &block)
           end
         end
-        # rubocop:enable Naming/MethodParameterName
 
-        def define_method_global_attribute(attr_name, owner:)
+        def define_method_global_attribute(attr_name, owner:, as: attr_name)
           if sharded_column?(attr_name)
-            define_cached_method(owner, "global_#{attr_name}", as: "sharded_global_#{attr_name}", namespace: :switchman) do |batch|
+            define_cached_method(owner,
+                                 "sharded_global_#{attr_name}",
+                                 as: "global_#{as}",
+                                 namespace: :switchman) do |batch|
               batch << <<-RUBY
                 def sharded_global_#{attr_name}
                   raw_value = original_#{attr_name}
@@ -71,13 +82,16 @@ module Switchman
               RUBY
             end
           else
-            define_method_unsharded_column(attr_name, 'global', owner)
+            define_method_unsharded_column(attr_name, "global", owner)
           end
         end
 
-        def define_method_local_attribute(attr_name, owner:)
+        def define_method_local_attribute(attr_name, owner:, as: attr_name)
           if sharded_column?(attr_name)
-            define_cached_method(owner, "local_#{attr_name}", as: "sharded_local_#{attr_name}", namespace: :switchman) do |batch|
+            define_cached_method(owner,
+                                 "sharded_local_#{attr_name}",
+                                 as: "local_#{as}",
+                                 namespace: :switchman) do |batch|
               batch << <<-RUBY
                 def sharded_local_#{attr_name}
                   raw_value = original_#{attr_name}
@@ -87,7 +101,7 @@ module Switchman
               RUBY
             end
           else
-            define_method_unsharded_column(attr_name, 'local', owner)
+            define_method_unsharded_column(attr_name, "local", owner)
           end
         end
 
@@ -99,7 +113,13 @@ module Switchman
             if reflection.options[:polymorphic]
               # a polymorphic association has to be discovered at runtime. This code ends up being something like
               # context_type.&.constantize&.connection_class_for_self
-              "begin;read_attribute(:#{reflection.foreign_type})&.constantize&.connection_class_for_self;rescue NameError;::ActiveRecord::Base;end"
+              <<~RUBY
+                begin
+                  read_attribute(:#{reflection.foreign_type})&.constantize&.connection_class_for_self
+                rescue NameError
+                  ::ActiveRecord::Base
+                end
+              RUBY
             else
               # otherwise we can just return a symbol for the statically known type of the association
               "::#{reflection.klass.connection_class_for_self.name}"
@@ -109,16 +129,21 @@ module Switchman
           end
         end
 
-        def define_method_attribute(attr_name, owner:)
+        def define_method_attribute(attr_name, owner:, as: attr_name)
           if sharded_column?(attr_name)
             reflection = reflection_for_integer_attribute(attr_name)
             class_name = connection_class_for_self_code_for_reflection(reflection)
-            safe_class_name = class_name.unpack1('h*')
-            define_cached_method(owner, attr_name, as: "sharded_#{safe_class_name}_#{attr_name}", namespace: :switchman) do |batch|
-              batch << build_sharded_getter("sharded_#{safe_class_name}_#{attr_name}", "original_#{attr_name}", class_name)
+            safe_class_name = class_name.unpack1("h*")
+            define_cached_method(owner,
+                                 "sharded_#{safe_class_name}_#{attr_name}",
+                                 as:,
+                                 namespace: :switchman) do |batch|
+              batch << build_sharded_getter("sharded_#{safe_class_name}_#{attr_name}",
+                                            "original_#{as}",
+                                            class_name)
             end
           else
-            define_cached_method(owner, attr_name, as: "plain_#{attr_name}", namespace: :switchman) do |batch|
+            define_cached_method(owner, "plain_#{attr_name}", as:, namespace: :switchman) do |batch|
               batch << <<-RUBY
                 def plain_#{attr_name}
                   _read_attribute("#{attr_name}") { |n| missing_attribute(n, caller) }
@@ -136,7 +161,7 @@ module Switchman
 
               abs_raw_value = raw_value.abs
               current_shard = ::Switchman::Shard.current(#{attr_connection_class})
-              same_shard = shard == current_shard
+              same_shard = loaded_from_shard == current_shard
               return raw_value if same_shard && abs_raw_value < ::Switchman::Shard::IDS_PER_SHARD
 
               value_shard_id = abs_raw_value / ::Switchman::Shard::IDS_PER_SHARD
@@ -144,23 +169,26 @@ module Switchman
               # of a local id
               return raw_value % ::Switchman::Shard::IDS_PER_SHARD if value_shard_id == current_shard.id
               return raw_value if !same_shard && abs_raw_value > ::Switchman::Shard::IDS_PER_SHARD
-              return shard.global_id_for(raw_value) if !same_shard && abs_raw_value < ::Switchman::Shard::IDS_PER_SHARD
+              return loaded_from_shard.global_id_for(raw_value) if !same_shard && abs_raw_value < ::Switchman::Shard::IDS_PER_SHARD
 
-              ::Switchman::Shard.relative_id_for(raw_value, shard, current_shard)
+              ::Switchman::Shard.relative_id_for(raw_value, loaded_from_shard, current_shard)
             end
           RUBY
         end
 
-        def define_method_attribute=(attr_name, owner:)
+        def define_method_attribute=(attr_name, owner:, as: attr_name)
           if sharded_column?(attr_name)
             reflection = reflection_for_integer_attribute(attr_name)
             class_name = connection_class_for_self_code_for_reflection(reflection)
-            safe_class_name = class_name.unpack1('h*')
-            define_cached_method(owner, "#{attr_name}=", as: "sharded_#{safe_class_name}_#{attr_name}=", namespace: :switchman) do |batch|
+            safe_class_name = class_name.unpack1("h*")
+            define_cached_method(owner,
+                                 "sharded_#{safe_class_name}_#{attr_name}=",
+                                 as: "#{as}=",
+                                 namespace: :switchman) do |batch|
               batch << build_sharded_setter("sharded_#{safe_class_name}_#{attr_name}", attr_name, class_name)
             end
           else
-            define_cached_method(owner, "#{attr_name}=", as: "plain_#{attr_name}=", namespace: :switchman) do |batch|
+            define_cached_method(owner, "plain_#{attr_name}=", as: "#{as}=", namespace: :switchman) do |batch|
               batch << <<-RUBY
                 def plain_#{attr_name}=(new_value)
                   _write_attribute('#{attr_name}', new_value)
@@ -173,14 +201,17 @@ module Switchman
         def build_sharded_setter(attr_name, attr_field, attr_connection_class)
           <<-RUBY
             def #{attr_name}=(new_value)
-              self.original_#{attr_field} = ::Switchman::Shard.relative_id_for(new_value, ::Switchman::Shard.current(#{attr_connection_class}), shard)
+              self.original_#{attr_field} = ::Switchman::Shard.relative_id_for(new_value, ::Switchman::Shard.current(#{attr_connection_class}), loaded_from_shard)
             end
           RUBY
         end
 
-        def define_method_original_attribute(attr_name, owner:)
+        def define_method_original_attribute(attr_name, owner:, as: attr_name)
           if sharded_column?(attr_name)
-            define_cached_method(owner, "original_#{attr_name}", as: "sharded_original_#{attr_name}", namespace: :switchman) do |batch|
+            define_cached_method(owner,
+                                 "sharded_original_#{attr_name}",
+                                 as: "original_#{as}",
+                                 namespace: :switchman) do |batch|
               batch << <<-RUBY
                 def sharded_original_#{attr_name}
                   _read_attribute("#{attr_name}") { |n| missing_attribute(n, caller) }
@@ -188,14 +219,17 @@ module Switchman
               RUBY
             end
           else
-            define_method_unsharded_column(attr_name, 'global', owner)
+            define_method_unsharded_column(attr_name, "global", owner)
           end
         end
 
-        def define_method_original_attribute=(attr_name, owner:)
+        def define_method_original_attribute=(attr_name, owner:, as: attr_name)
           return unless sharded_column?(attr_name)
 
-          define_cached_method(owner, "original_#{attr_name}=", as: "sharded_original_#{attr_name}=", namespace: :switchman) do |batch|
+          define_cached_method(owner,
+                               "sharded_original_#{attr_name}=",
+                               as: "original_#{as}=",
+                               namespace: :switchman) do |batch|
             batch << <<-RUBY
               def sharded_original_#{attr_name}=(new_value)
                 _write_attribute('#{attr_name}', new_value)
@@ -205,9 +239,12 @@ module Switchman
         end
 
         def define_method_unsharded_column(attr_name, prefix, owner)
-          return if columns_hash["#{prefix}_#{attr_name}"] || attr_name == 'id'
+          return if columns_hash["#{prefix}_#{attr_name}"] || attr_name == "id"
 
-          define_cached_method(owner, "#{prefix}_#{attr_name}", as: "unsharded_#{prefix}_#{attr_name}", namespace: :switchman) do |batch|
+          define_cached_method(owner,
+                               "unsharded_#{prefix}_#{attr_name}",
+                               as: "#{prefix}_#{attr_name}",
+                               namespace: :switchman) do |batch|
             batch << <<-RUBY
               def unsharded_#{prefix}_#{attr_name}
                 raise NoMethodError, "undefined method `#{prefix}_#{attr_name}'; are you missing an association?"
@@ -219,8 +256,8 @@ module Switchman
 
       def self.prepended(klass)
         klass.singleton_class.prepend(ClassMethods)
-        klass.attribute_method_prefix 'global_', 'local_', 'original_'
-        klass.attribute_method_affix prefix: 'original_', suffix: '='
+        klass.attribute_method_prefix "global_", "local_", "original_"
+        klass.attribute_method_affix prefix: "original_", suffix: "="
       end
 
       # these are called if the specific methods haven't been defined yet
@@ -228,7 +265,11 @@ module Switchman
         return super unless self.class.sharded_column?(attr_name)
 
         reflection = self.class.send(:reflection_for_integer_attribute, attr_name)
-        ::Switchman::Shard.relative_id_for(super, shard, ::Switchman::Shard.current(connection_class_for_self_for_reflection(reflection)))
+        ::Switchman::Shard.relative_id_for(
+          super,
+          shard,
+          ::Switchman::Shard.current(connection_class_for_self_for_reflection(reflection))
+        )
       end
 
       def attribute=(attr_name, new_value)
@@ -238,7 +279,11 @@ module Switchman
         end
 
         reflection = self.class.send(:reflection_for_integer_attribute, attr_name)
-        super(::Switchman::Shard.relative_id_for(new_value, ::Switchman::Shard.current(connection_class_for_self_for_reflection(reflection)), shard))
+        super(attr_name, ::Switchman::Shard.relative_id_for(
+          new_value,
+          ::Switchman::Shard.current(connection_class_for_self_for_reflection(reflection)),
+          shard
+        ))
       end
 
       def global_attribute(attr_name)
@@ -251,7 +296,7 @@ module Switchman
 
       def local_attribute(attr_name)
         if self.class.sharded_column?(attr_name)
-          ::Switchman::Shard.local_id_for(attribute(attr_name), shard).first
+          ::Switchman::Shard.local_id_for(attribute(attr_name)).first
         else
           attribute(attr_name)
         end