switchman 3.2.1 → 3.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 20c8d947a29c73c09af7d1c880ef03aff2185c927d30954bb304b4592a7b4051
-  data.tar.gz: 5973474196cc2c8f2957932a65261998de24a6be3653cedeff374c1fe1fa925f
+  metadata.gz: 0730763611a9f47cf3b9a39d5e3a9969189067772c743bad82729c670d18e545
+  data.tar.gz: 4136ab04f9eac6c48ae4ad7a70b284845f095e3fc4153a8d5a5023f2bc5e312d
 SHA512:
-  metadata.gz: 10f59abb9c44a3b6e8ec3e87419862f5959ec8086117172d6fc044911c0efb3d96ec320fc04630e482200fbf99da4a7a8d7a291137bbf9ce019f1e7a54f5eeb0
-  data.tar.gz: 72fc286e4f143bf9d8344aa6e4a0405161e476b23eada4fd956f2657a1911c4e93acad649e76cb17e444821060085110d12c2cfe0a5f115bf9b7ddc598fb17ea
+  metadata.gz: ad391b862e5428999a5260278e767dae4a1266eb99fd2bab18619b26302542d67d50fee3277ff27711ce4eaec68fbf5428773d17b03b7d235e501baeb06a1623
+  data.tar.gz: 87cee001748bcea7ce0f46a4d673a2c7ac3aefb16b99f84d463fbaff3804a98cd53184dd271a3b19261f89baef91151d85728076b76484646d5be95af1f101cb

data/lib/switchman/active_record/query_methods.rb

@@ -12,8 +12,6 @@ module Switchman
       #   :explicit    - explicit set on the relation
       #   :association - a special value that scopes from associations use to use slightly different logic
       #                  for foreign key transposition
-      #   :to_a        - a special value that Relation#to_a uses when querying multiple shards to
-      #                  remove primary keys from conditions that aren't applicable to the current shard
       def shard_value
         @values[:shard]
       end
@@ -44,10 +42,7 @@ module Switchman
         old_primary_shard = primary_shard
         self.shard_value = value
         self.shard_source_value = source
-        if old_primary_shard != primary_shard || source == :to_a
-          transpose_clauses(old_primary_shard, primary_shard,
-                            remove_nonlocal_primary_keys: source == :to_a)
-        end
+        transpose_predicates(nil, old_primary_shard, primary_shard) if old_primary_shard != primary_shard
         self
       end
 
@@ -89,29 +84,21 @@ module Switchman
         super(other.shard(primary_shard))
       end
 
-      private
+      protected
 
-      %i[where having].each do |type|
-        class_eval <<-RUBY, __FILE__, __LINE__ + 1
-        def transpose_#{type}_clauses(source_shard, target_shard, remove_nonlocal_primary_keys:)
-          unless (predicates = #{type}_clause.send(:predicates)).empty?
-            new_predicates = transpose_predicates(predicates, source_shard,
-                                                              target_shard, remove_nonlocal_primary_keys: remove_nonlocal_primary_keys)
-            if new_predicates != predicates
-              self.#{type}_clause = #{type}_clause.dup
-              if new_predicates != predicates
-                #{type}_clause.instance_variable_set(:@predicates, new_predicates)
-              end
-            end
-          end
+      def remove_nonlocal_primary_keys!
+        each_transposable_predicate_value do |value, predicate, _relation, _column, type|
+          next value unless
+            type == :primary &&
+            predicate.left.relation.klass == klass &&
+            (predicate.is_a?(::Arel::Nodes::Equality) || predicate.is_a?(::Arel::Nodes::HomogeneousIn))
+
+          value.is_a?(Integer) && value > Shard::IDS_PER_SHARD ? [] : value
         end
-        RUBY
+        self
       end
 
-      def transpose_clauses(source_shard, target_shard, remove_nonlocal_primary_keys: false)
-        transpose_where_clauses(source_shard, target_shard, remove_nonlocal_primary_keys: remove_nonlocal_primary_keys)
-        transpose_having_clauses(source_shard, target_shard, remove_nonlocal_primary_keys: remove_nonlocal_primary_keys)
-      end
+      private
 
       def infer_shards_from_primary_key(predicates)
         return unless klass.integral_id?
@@ -145,7 +132,7 @@ module Switchman
             return
           else
             id_shards = id_shards.to_a
-            transpose_clauses(primary_shard, id_shards.first)
+            transpose_predicates(nil, primary_shard, id_shards.first)
             self.shard_value = id_shards
             return
           end
@@ -162,7 +149,7 @@ module Switchman
 
         return if !id_shard || id_shard == primary_shard
 
-        transpose_clauses(primary_shard, id_shard)
+        transpose_predicates(nil, primary_shard, id_shard)
         self.shard_value = id_shard
       end
 
@@ -246,122 +233,129 @@ module Switchman
         connection.with_global_table_name { super }
       end
 
-      def transpose_predicates(predicates,
-                               source_shard,
-                               target_shard,
-                               remove_nonlocal_primary_keys: false)
-        predicates.map do |predicate|
-          transpose_single_predicate(predicate, source_shard, target_shard,
-                                     remove_nonlocal_primary_keys: remove_nonlocal_primary_keys)
-        end
+      def each_predicate(predicates = nil, &block)
+        return predicates.map(&block) if predicates
+
+        each_predicate_cb(:having_clause, :having_clause=, &block)
+        each_predicate_cb(:where_clause, :where_clause=, &block)
       end
 
-      def transpose_single_predicate(predicate,
-                                     source_shard,
-                                     target_shard,
-                                     remove_nonlocal_primary_keys: false)
-        if predicate.is_a?(::Arel::Nodes::Grouping)
-          return predicate unless predicate.expr.is_a?(::Arel::Nodes::Or)
-
-          # Dang, we have an OR.  OK, that means we have other epxressions below this
-          # level, perhaps many, that may need transposition.
-          # the left side and right side must each be treated as predicate lists and
-          # transformed in kind, if neither of them changes we can just return the grouping as is.
-          # hold on, it's about to get recursive...
-          or_expr = predicate.expr
-          left_node = or_expr.left
-          right_node = or_expr.right
-          new_left_predicates = transpose_single_predicate(left_node, source_shard,
-                                                           target_shard, remove_nonlocal_primary_keys: remove_nonlocal_primary_keys)
-          new_right_predicates = transpose_single_predicate(right_node, source_shard,
-                                                            target_shard, remove_nonlocal_primary_keys: remove_nonlocal_primary_keys)
-          return predicate if new_left_predicates == left_node && new_right_predicates == right_node
-
-          return ::Arel::Nodes::Grouping.new ::Arel::Nodes::Or.new(new_left_predicates, new_right_predicates)
-        end
-        return predicate unless predicate.is_a?(::Arel::Nodes::Binary) || predicate.is_a?(::Arel::Nodes::HomogeneousIn)
-        return predicate unless predicate.left.is_a?(::Arel::Attributes::Attribute)
-
-        relation, column = relation_and_column(predicate.left)
-        return predicate unless (type = transposable_attribute_type(relation, column))
-
-        remove = true if type == :primary &&
-                         remove_nonlocal_primary_keys &&
-                         predicate.left.relation.klass == klass &&
-                         (predicate.is_a?(::Arel::Nodes::Equality) || predicate.is_a?(::Arel::Nodes::HomogeneousIn))
-
-        current_source_shard =
-          if source_shard
-            source_shard
-          elsif type == :primary
-            Shard.current(klass.connection_class_for_self)
-          elsif type == :foreign
-            source_shard_for_foreign_key(relation, column)
-          end
+      def each_predicate_cb(clause_getter, clause_setter, &block)
+        old_clause = send(clause_getter)
+        old_predicates = old_clause.send(:predicates)
+        return if old_predicates.empty?
 
-        right = if predicate.is_a?(::Arel::Nodes::HomogeneousIn)
-                  predicate.values
-                else
-                  predicate.right
-                end
+        new_predicates = old_predicates.map(&block)
+        return if new_predicates == old_predicates
 
-        new_right_value =
-          case right
-          when Array
-            right.map { |val| transpose_predicate_value(val, current_source_shard, target_shard, type, remove).presence }.compact
-          else
-            transpose_predicate_value(right, current_source_shard, target_shard, type, remove)
+        new_clause = old_clause.dup
+        new_clause.instance_variable_set(:@predicates, new_predicates)
+
+        send(clause_setter, new_clause)
+      end
+
+      def each_transposable_predicate(predicates = nil, &block)
+        each_predicate(predicates) do |predicate|
+          if predicate.is_a?(::Arel::Nodes::Grouping)
+            next predicate unless predicate.expr.is_a?(::Arel::Nodes::Or)
+
+            or_expr = predicate.expr
+            old_left = or_expr.left
+            old_right = or_expr.right
+            new_left, new_right = each_transposable_predicate([old_left, old_right], &block)
+
+            next predicate if new_left == old_left && new_right == old_right
+
+            next predicate.class.new predicate.expr.class.new(new_left, new_right)
           end
 
-        if new_right_value == right
-          predicate
-        elsif predicate.right.is_a?(::Arel::Nodes::Casted)
-          if new_right_value == right.value
-            predicate
-          else
-            predicate.class.new(predicate.left, right.class.new(new_right_value, right.attribute))
+          next predicate unless predicate.is_a?(::Arel::Nodes::Binary) || predicate.is_a?(::Arel::Nodes::HomogeneousIn)
+          next predicate unless predicate.left.is_a?(::Arel::Attributes::Attribute)
+
+          relation, column = relation_and_column(predicate.left)
+          next predicate unless (type = transposable_attribute_type(relation, column))
+
+          yield(predicate, relation, column, type)
+        end
+      end
+
+      def each_transposable_predicate_value(predicates = nil)
+        each_transposable_predicate(predicates) do |predicate, relation, column, type|
+          each_transposable_predicate_value_cb(predicate) do |value|
+            yield(value, predicate, relation, column, type)
           end
-        elsif predicate.is_a?(::Arel::Nodes::HomogeneousIn)
+        end
+      end
+
+      def each_transposable_predicate_value_cb(node, &block)
+        case node
+        when Array
+          node.map { |val| each_transposable_predicate_value_cb(val, &block).presence }.compact
+        when ::ActiveModel::Attribute
+          old_value = node.value_before_type_cast
+          new_value = each_transposable_predicate_value_cb(old_value, &block)
+
+          old_value == new_value ? node : node.class.new(node.name, new_value, node.type)
+        when ::Arel::Nodes::And
+          old_value = node.children
+          new_value = each_transposable_predicate_value_cb(old_value, &block)
+
+          old_value == new_value ? node : node.class.new(new_value)
+        when ::Arel::Nodes::BindParam
+          old_value = node.value
+          new_value = each_transposable_predicate_value_cb(old_value, &block)
+
+          old_value == new_value ? node : node.class.new(new_value)
+        when ::Arel::Nodes::Casted
+          old_value = node.value
+          new_value = each_transposable_predicate_value_cb(old_value, &block)
+
+          old_value == new_value ? node : node.class.new(new_value, node.attribute)
+        when ::Arel::Nodes::HomogeneousIn
+          old_value = node.values
+          new_value = each_transposable_predicate_value_cb(old_value, &block)
+
           # switch to a regular In, so that Relation::WhereClause#contradiction? knows about it
-          if new_right_value.empty?
-            klass = predicate.type == :in ? ::Arel::Nodes::In : ::Arel::Nodes::NotIn
-            klass.new(predicate.attribute, new_right_value)
+          if new_value.empty?
+            klass = node.type == :in ? ::Arel::Nodes::In : ::Arel::Nodes::NotIn
+            klass.new(node.attribute, new_value)
           else
-            predicate.class.new(new_right_value, predicate.attribute, predicate.type)
+            old_value == new_value ? node : node.class.new(new_value, node.attribute, node.type)
           end
+        when ::Arel::Nodes::Binary
+          old_value = node.right
+          new_value = each_transposable_predicate_value_cb(old_value, &block)
+
+          old_value == new_value ? node : node.class.new(node.left, new_value)
         else
-          predicate.class.new(predicate.left, new_right_value)
+          yield(node)
         end
       end
 
-      def transpose_predicate_value(value, current_shard, target_shard, attribute_type, remove_non_local_ids)
-        case value
-        when ::Arel::Nodes::BindParam, ::ActiveModel::Attribute
-          query_att = value.is_a?(::ActiveModel::Attribute) ? value : value.value
-          current_id = query_att.value_before_type_cast
-          if current_id.is_a?(::ActiveRecord::StatementCache::Substitute)
-            current_id.sharded = true # mark for transposition later
-            current_id.primary = true if attribute_type == :primary
-            value
-          else
-            local_id = Shard.relative_id_for(current_id, current_shard, target_shard) || current_id
-            local_id = [] if remove_non_local_ids && local_id.is_a?(Integer) && local_id > Shard::IDS_PER_SHARD
-            if current_id == local_id
-              # make a new bind param
-              value
-            else
-              new_att = query_att.class.new(query_att.name, local_id, query_att.type)
-              if value.is_a?(::ActiveModel::Attribute)
-                new_att
-              else
-                ::Arel::Nodes::BindParam.new(new_att)
-              end
+      def transpose_predicates(predicates,
+                               source_shard,
+                               target_shard)
+        each_transposable_predicate_value(predicates) do |value, _predicate, relation, column, type|
+          current_source_shard =
+            if source_shard
+              source_shard
+            elsif type == :primary
+              Shard.current(klass.connection_class_for_self)
+            elsif type == :foreign
+              source_shard_for_foreign_key(relation, column)
             end
-          end
+
+          transpose_predicate_value(value, current_source_shard, target_shard, type)
+        end
+      end
+
+      def transpose_predicate_value(value, current_shard, target_shard, attribute_type)
+        if value.is_a?(::ActiveRecord::StatementCache::Substitute)
+          value.sharded = true # mark for transposition later
+          value.primary = true if attribute_type == :primary
+          value
         else
-          local_id = Shard.relative_id_for(value, current_shard, target_shard) || value
-          local_id = [] if remove_non_local_ids && local_id.is_a?(Integer) && local_id > Shard::IDS_PER_SHARD
-          local_id
+          Shard.relative_id_for(value, current_shard, target_shard) || value
         end
       end
     end

data/lib/switchman/active_record/relation.rb

@@ -103,7 +103,9 @@ module Switchman
       def activate(unordered: false, &block)
         shards = all_shards
         if Array === shards && shards.length == 1
-          if shards.first == DefaultShard || shards.first == Shard.current(klass.connection_class_for_self)
+          if !loaded? && shard_value != shards.first
+            shard(shards.first).activate(&block)
+          elsif shards.first == DefaultShard || shards.first == Shard.current(klass.connection_class_for_self)
             yield(self, shards.first)
           else
             shards.first.activate(klass.connection_class_for_self) { yield(self, shards.first) }
@@ -115,7 +117,8 @@ module Switchman
             # don't even query other shards if we're already past the limit
             next if limit_value && result_count >= limit_value && order_values.empty?
 
-            relation = shard(Shard.current(klass.connection_class_for_self), :to_a)
+            relation = shard(Shard.current(klass.connection_class_for_self))
+            relation.remove_nonlocal_primary_keys!
             # do a minimal query if possible
             relation = relation.limit(limit_value - result_count) if limit_value && !result_count.zero? && order_values.empty?
 

data/lib/switchman/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Switchman
-  VERSION = '3.2.1'
+  VERSION = '3.3.0'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: switchman
 version: !ruby/object:Gem::Version
-  version: 3.2.1
+  version: 3.3.0
 platform: ruby
 authors:
 - Cody Cutrer
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-11-22 00:00:00.000000000 Z
+date: 2022-12-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord