switchman 4.0.0 → 4.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: eb5bc75d858d97e55442dfdafcd1826d7040fe1bd4819bc3c2ee6053257a72ab
-  data.tar.gz: e73beaf3a5987f26e2402078f66c028831afc6924f21546d0ca1cb35f70e0831
+  metadata.gz: cfb4e89f881628a5d90c8f309ddf587fdc5bfebe5bc7985c79fea9dd06e7168c
+  data.tar.gz: baa3202cd9fb68347d71d43adecdbe3124fe3f4f604558f92546e8fa5c5b4773
 SHA512:
-  metadata.gz: 273718d8bc773ded149ac5d81509a6d85c6858f17bc7c1a03f3dbdf15bbb96f101fea5842eddf87ba442aabf1f0bffe1a21421da4b9329548b0f40e51de26645
-  data.tar.gz: 9f81d1963fe213d334aed7377057fe29ecbdb637c6b2b8a33a49d52fcc0f726e1a8e87853a6e1030c8c2b0bbaff51e369d54cf8118f1c512ca0d62bf5684267c
+  metadata.gz: c351d3ff898e668ac7a8c8ab40e9cf2249f428a2d2bbc9a16573334e1599cb9bcac20a47a3534e70b7900fd76ca55f6f4a8625c9dc7c8bb3ef1b4ade95a17ff3
+  data.tar.gz: e3205573c3bbf8d8bf8a1e87beaaaed1adc2dba268f53ec1bac8c870f29f51ecdce923028eaa8528cffb9250965fc7b72d8d2dce4882c63edb0ad0d66d624a57

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,12 +27,6 @@ module Switchman
         quote_table_name(name)
       end
 
-      if ::Rails.version < "7.1"
-        def schema_migration
-          ::ActiveRecord::SchemaMigration
-        end
-      end
-
       protected
 
       def log(...)

data/lib/switchman/active_record/associations.rb

@@ -23,7 +23,7 @@ module Switchman
       end
 
       module CollectionAssociation
-        def find_target
+        def find_target(async: false)
           shards = if reflection.options[:multishard] && owner.respond_to?(:associated_shards)
                      owner.associated_shards
                    else
@@ -38,6 +38,8 @@ module Switchman
               # 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
+            elsif ::Rails.version < "8.0"
+              super()
             else
               super
             end
@@ -174,7 +176,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)
@@ -191,7 +193,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
@@ -251,78 +253,60 @@ module Switchman
           self.shard_source_value = :association
         end
 
-        def shard(*args)
-          scope.shard(*args)
+        def shard(*)
+          scope.shard(*)
         end
       end
 
       module AutosaveAssociation
-        if ::Rails.version < "7.1"
-          def association_foreign_key_changed?(reflection, record, key)
-            return false if reflection.through_reflection?
+        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 }
-          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) }
 
-            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
 
-            # 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?
 
-          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?
 
-            record = association.load_target
-            return unless record && !record.destroyed?
+          autosave = reflection.options[:autosave]
 
-            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
+            saved = record.save(validate: !autosave) if record.new_record? || (autosave && record.changed_for_autosave?)
 
-            if autosave && record.marked_for_destruction?
+            if association.updated?
+              primary_key = Array(compute_primary_key(reflection, record)).map(&:to_s)
               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!
+              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
-
-              saved if autosave
+              association.loaded!
             end
+
+            saved if autosave
           end
         end
       end

data/lib/switchman/active_record/attribute_methods.rb

@@ -26,10 +26,10 @@ 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)
+          return result unless sharded_column?(@primary_key)
 
           class_eval(
             build_sharded_getter("id",
@@ -41,6 +41,7 @@ module Switchman
           class_eval(build_sharded_setter("id", @primary_key, "::#{connection_class_for_self.name}"),
                      __FILE__,
                      __LINE__)
+          result
         end
 
         protected
@@ -54,15 +55,21 @@ module Switchman
           raise if connection.open_transactions.positive?
         end
 
-        def define_cached_method(owner, name, namespace:, as:, &block)
-          owner.define_cached_method(name, namespace: namespace, as: as, &block)
+        def define_cached_method(owner, name, namespace:, as:, &)
+          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, &)
+          else
+            owner.define_cached_method(name, namespace:, as:, &)
+          end
         end
 
-        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}",
+                                 "sharded_global_#{attr_name}",
+                                 as: "global_#{as}",
                                  namespace: :switchman) do |batch|
               batch << <<-RUBY
                 def sharded_global_#{attr_name}
@@ -79,11 +86,11 @@ module Switchman
           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}",
+                                 "sharded_local_#{attr_name}",
+                                 as: "local_#{as}",
                                  namespace: :switchman) do |batch|
               batch << <<-RUBY
                 def sharded_local_#{attr_name}
@@ -122,21 +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}",
+                                 "sharded_#{safe_class_name}_#{attr_name}",
+                                 as:,
                                  namespace: :switchman) do |batch|
               batch << build_sharded_getter("sharded_#{safe_class_name}_#{attr_name}",
-                                            "original_#{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) }
@@ -169,19 +176,19 @@ module Switchman
           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}=",
+                                 "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)
@@ -199,11 +206,11 @@ module Switchman
           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}",
+                                 "sharded_original_#{attr_name}",
+                                 as: "original_#{as}",
                                  namespace: :switchman) do |batch|
               batch << <<-RUBY
                 def sharded_original_#{attr_name}
@@ -216,12 +223,12 @@ module Switchman
           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}=",
+                               "sharded_original_#{attr_name}=",
+                               as: "original_#{as}=",
                                namespace: :switchman) do |batch|
             batch << <<-RUBY
               def sharded_original_#{attr_name}=(new_value)
@@ -235,8 +242,8 @@ module Switchman
           return if columns_hash["#{prefix}_#{attr_name}"] || attr_name == "id"
 
           define_cached_method(owner,
-                               "#{prefix}_#{attr_name}",
-                               as: "unsharded_#{prefix}_#{attr_name}",
+                               "unsharded_#{prefix}_#{attr_name}",
+                               as: "#{prefix}_#{attr_name}",
                                namespace: :switchman) do |batch|
             batch << <<-RUBY
               def unsharded_#{prefix}_#{attr_name}

data/lib/switchman/active_record/base.rb

@@ -6,9 +6,9 @@ module Switchman
       module ClassMethods
         delegate :shard, to: :all
 
-        def find_ids_in_ranges(opts = {}, &block)
+        def find_ids_in_ranges(opts = {}, &)
           opts.reverse_merge!(loose: true)
-          all.find_ids_in_ranges(opts, &block)
+          all.find_ids_in_ranges(opts, &)
         end
 
         def sharded_model
@@ -34,56 +34,6 @@ module Switchman
           end
         end
 
-        # NOTE: `returning` values are _not_ transposed back to the current shard
-        %w[insert_all upsert_all].each do |method|
-          class_eval <<-RUBY, __FILE__, __LINE__ + 1
-            def #{method}(attributes, returning: nil, **)
-              scope = self != ::ActiveRecord::Base && current_scope
-              if (target_shard = scope&.primary_shard) == (current_shard = Shard.current(connection_class_for_self))
-                scope = nil
-              end
-              if scope
-                dupped = false
-                attributes.each_with_index do |hash, i|
-                  if dupped || hash.any? { |k, v| sharded_column?(k) }
-                    unless dupped
-                      attributes = attributes.dup
-                      dupped = true
-                    end
-                    attributes[i] = hash.to_h do |k, v|
-                      if sharded_column?(k)
-                        [k, Shard.relative_id_for(v, current_shard, target_shard)]
-                      else
-                        [k, v]
-                      end
-                    end
-                  end
-                end
-              end
-
-              if scope
-                scope.activate do
-                  db = Shard.current(connection_class_for_self).database_server
-                  result = db.unguard { super }
-                  if result&.columns&.any? { |c| sharded_column?(c) }
-                    transposed_rows = result.rows.map do |row|
-                      row.map.with_index do |value, i|
-                        sharded_column?(result.columns[i]) ? Shard.relative_id_for(value, target_shard, current_shard) : value
-                      end
-                    end
-                    result = ::ActiveRecord::Result.new(result.columns, transposed_rows, result.column_types)
-                  end
-
-                  result
-                end
-              else
-                db = Shard.current(connection_class_for_self).database_server
-                db.unguard { super }
-              end
-            end
-          RUBY
-        end
-
         def reset_column_information
           @sharded_column_values = {}
           super
@@ -103,13 +53,13 @@ module Switchman
         end
 
         def clear_query_caches_for_current_thread
-          pools = if ::Rails.version < "7.1"
-                    ::ActiveRecord::Base.connection_handler.connection_pool_list
-                  else
-                    ::ActiveRecord::Base.connection_handler.connection_pool_list(:all)
-                  end
+          pools = ::ActiveRecord::Base.connection_handler.connection_pool_list(:all)
           pools.each do |pool|
-            pool.connection(switch_shard: false).clear_query_cache if pool.active_connection?
+            if ::Rails.version < "7.2"
+              pool.connection(switch_shard: false).clear_query_cache if pool.active_connection?
+            elsif pool.active_connection?
+              pool.lease_connection(switch_shard: false).clear_query_cache
+            end
           end
         end
 
@@ -132,7 +82,7 @@ module Switchman
                               :"#{current_shard}/#{current_role}"
                             end
 
-          super(config_or_env)
+          super
         end
 
         def connected_to_stack
@@ -189,8 +139,9 @@ module Switchman
 
       def self.prepended(klass)
         klass.singleton_class.prepend(ClassMethods)
+        klass.singleton_class.prepend(Switchman::ActiveRecord::Relation::InsertUpsertAll) if ::Rails.version < "7.2"
         klass.scope :non_shadow, lambda { |key = primary_key|
-                                   where(key => (QueryMethods::NonTransposingValue.new(0)..
+                                   where(key => (QueryMethods::NonTransposingValue.new(0)...
                                                  QueryMethods::NonTransposingValue.new(Shard::IDS_PER_SHARD)))
                                  }
         klass.scope :shadow, lambda { |key = primary_key|
@@ -241,7 +192,7 @@ module Switchman
                                end
         end
         target_shard.activate do
-          self.class.upsert(shadow_attrs, unique_by: self.class.primary_key)
+          self.class.upsert_all([shadow_attrs], unique_by: self.class.primary_key)
         end
       end
 

data/lib/switchman/active_record/calculations.rb

@@ -95,7 +95,7 @@ module Switchman
             opts[:group_columns].each do |aliaz, _type, group_column_name|
               if opts[:associated] && (aliaz == opts[:group_aliases].first)
                 row[aliaz] = key_records[Shard.relative_id_for(row[aliaz], shard, target_shard)]
-              elsif group_column_name && @klass.sharded_column?(group_column_name)
+              elsif group_column_name && klass.sharded_column?(group_column_name)
                 row[aliaz] = Shard.relative_id_for(row[aliaz], shard, target_shard)
               end
             end
@@ -106,41 +106,39 @@ module Switchman
         compact_grouped_calculation_rows(rows, opts)
       end
 
-      if ::Rails.version >= "7.1"
-        def ids
-          return super unless klass.sharded_primary_key?
+      def ids
+        return super unless klass.sharded_primary_key?
 
-          if loaded?
-            result = records.map do |record|
-              Shard.relative_id_for(record._read_attribute(primary_key),
-                                    record.shard,
-                                    Shard.current(klass.connection_class_for_self))
-            end
-            return @async ? Promise::Complete.new(result) : result
+        if loaded?
+          result = records.map do |record|
+            Shard.relative_id_for(record._read_attribute(primary_key),
+                                  record.shard,
+                                  Shard.current(klass.connection_class_for_self))
           end
+          return @async ? Promise::Complete.new(result) : result
+        end
 
-          if has_include?(primary_key)
-            relation = apply_join_dependency.group(primary_key)
-            return relation.ids
-          end
+        if has_include?(primary_key)
+          relation = apply_join_dependency.group(primary_key)
+          return relation.ids
+        end
 
-          columns = arel_columns([primary_key])
-          base_shard = Shard.current(klass.connection_class_for_self)
-          activate do |r|
-            relation = r.spawn
-            relation.select_values = columns
-
-            result = if relation.where_clause.contradiction?
-                       ::ActiveRecord::Result.empty
-                     else
-                       skip_query_cache_if_necessary do
-                         klass.connection.select_all(relation, "#{klass.name} Ids", async: @async)
-                       end
+        columns = arel_columns([primary_key])
+        base_shard = Shard.current(klass.connection_class_for_self)
+        activate do |r|
+          relation = r.spawn
+          relation.select_values = columns
+
+          result = if relation.where_clause.contradiction?
+                     ::ActiveRecord::Result.empty
+                   else
+                     skip_query_cache_if_necessary do
+                       klass.connection.select_all(relation, "#{klass.name} Ids", async: @async)
                      end
+                   end
 
-            result.then do |res|
-              type_cast_pluck_values(res, columns).map { |id| Shard.relative_id_for(id, Shard.current, base_shard) }
-            end
+          result.then do |res|
+            type_cast_pluck_values(res, columns).map { |id| Shard.relative_id_for(id, Shard.current, base_shard) }
           end
         end
       end
@@ -159,12 +157,9 @@ module Switchman
       end
 
       def grouped_calculation_options(operation, column_name, distinct)
-        opts = { operation: operation, column_name: column_name, distinct: distinct }
+        opts = { operation:, column_name:, distinct: }
 
-        # Rails 7.0.5
-        if defined?(::ActiveRecord::Calculations::ColumnAliasTracker)
-          column_alias_tracker = ::ActiveRecord::Calculations::ColumnAliasTracker.new(connection)
-        end
+        column_alias_tracker = ::ActiveRecord::Calculations::ColumnAliasTracker.new(connection)
 
         opts[:aggregate_alias] = aggregate_alias_for(operation, column_name, column_alias_tracker)
         group_attrs = group_values
@@ -179,20 +174,16 @@ module Switchman
 
         group_aliases = group_fields.map do |field|
           field = connection.visitor.compile(field) if ::Arel.arel_node?(field)
-          if column_alias_tracker
-            column_alias_tracker.alias_for(field.to_s.downcase)
-          else
-            column_alias_for(field.to_s.downcase)
-          end
+          column_alias_tracker.alias_for(field.to_s.downcase)
         end
         group_columns = group_aliases.zip(group_fields).map do |aliaz, field|
           [aliaz, type_for(field), column_name_for(field)]
         end
-        opts.merge!(association: association,
-                    associated: associated,
-                    group_aliases: group_aliases,
-                    group_columns: group_columns,
-                    group_fields: group_fields)
+        opts.merge!(association:,
+                    associated:,
+                    group_aliases:,
+                    group_columns:,
+                    group_fields:)
 
         opts
       end
@@ -202,10 +193,8 @@ module Switchman
           "count_all"
         elsif operation == "average"
           "average"
-        elsif column_alias_tracker
-          column_alias_tracker.alias_for("#{operation} #{column_name}")
         else
-          column_alias_for("#{operation} #{column_name}")
+          column_alias_tracker.alias_for("#{operation} #{column_name}")
         end
       end