composite_primary_keys 12.0.9 → 14.0.1

data/lib/composite_primary_keys/associations/association_scope.rb

@@ -1,69 +1,67 @@
-module ActiveRecord
-  module Associations
-    class AssociationScope
-      def self.get_bind_values(owner, chain)
-        binds = []
-        last_reflection = chain.last
-
-        # CPK
-        # binds << last_reflection.join_id_for(owner)
-        values = last_reflection.join_id_for(owner)
-        binds += Array(values)
-
-        if last_reflection.type
-          binds << owner.class.polymorphic_name
-        end
-
-        chain.each_cons(2).each do |reflection, next_reflection|
-          if reflection.type
-            binds << next_reflection.klass.polymorphic_name
-          end
-        end
-        binds
-      end
-
-      def last_chain_scope(scope, reflection, owner)
-        join_keys = reflection.join_keys
-        key = join_keys.key
-        foreign_key = join_keys.foreign_key
-
-        table = reflection.aliased_table
-
-        # CPK
-        # value = transform_value(owner[foreign_key])
-        # scope = apply_scope(scope, table, key, value)
-        Array(key).zip(Array(foreign_key)).each do |a_join_key, a_foreign_key|
-          value = transform_value(owner[a_foreign_key])
-          scope = apply_scope(scope, table, a_join_key, value)
-        end
-
-        if reflection.type
-          polymorphic_type = transform_value(owner.class.polymorphic_name)
-          scope = apply_scope(scope, table, reflection.type, polymorphic_type)
-        end
-
-        scope
-      end
-
-      def next_chain_scope(scope, reflection, next_reflection)
-        join_keys = reflection.join_keys
-        key = join_keys.key
-        foreign_key = join_keys.foreign_key
-
-        table = reflection.aliased_table
-        foreign_table = next_reflection.aliased_table
-
-        # CPK
-        # constraint = table[key].eq(foreign_table[foreign_key])
-        constraint = cpk_join_predicate(table, key, foreign_table, foreign_key)
-
-        if reflection.type
-          value = transform_value(next_reflection.klass.polymorphic_name)
-          scope = apply_scope(scope, table, reflection.type, value)
-        end
-
-        scope.joins!(join(foreign_table, constraint))
-      end
-    end
-  end
+module ActiveRecord
+  module Associations
+    class AssociationScope
+      def self.get_bind_values(owner, chain)
+        binds = []
+        last_reflection = chain.last
+
+        # CPK
+        # binds << last_reflection.join_id_for(owner)
+        values = last_reflection.join_id_for(owner)
+        binds += Array(values)
+
+        if last_reflection.type
+          binds << owner.class.polymorphic_name
+        end
+
+        chain.each_cons(2).each do |reflection, next_reflection|
+          if reflection.type
+            binds << next_reflection.klass.polymorphic_name
+          end
+        end
+        binds
+      end
+
+      def last_chain_scope(scope, reflection, owner)
+        key = reflection.join_primary_key
+        foreign_key = reflection.join_foreign_key
+
+        table = reflection.aliased_table
+
+        # CPK
+        # value = transform_value(owner[foreign_key])
+        # scope = apply_scope(scope, table, key, value)
+        Array(key).zip(Array(foreign_key)).each do |a_join_key, a_foreign_key|
+          value = transform_value(owner[a_foreign_key])
+          scope = apply_scope(scope, table, a_join_key, value)
+        end
+
+        if reflection.type
+          polymorphic_type = transform_value(owner.class.polymorphic_name)
+          scope = apply_scope(scope, table, reflection.type, polymorphic_type)
+        end
+
+        scope
+      end
+
+      def next_chain_scope(scope, reflection, next_reflection)
+        key = reflection.join_primary_key
+        foreign_key = reflection.join_foreign_key
+
+        table = reflection.aliased_table
+        foreign_table = next_reflection.aliased_table
+
+        # CPK
+        # constraint = table[key].eq(foreign_table[foreign_key])
+        constraint = cpk_join_predicate(table, key, foreign_table, foreign_key)
+
+        if reflection.type
+          value = transform_value(next_reflection.klass.polymorphic_name)
+          scope = apply_scope(scope, table, reflection.type, value)
+        end
+
+        scope.joins!(join(foreign_table, constraint))
+      end
+    end
+  end
 end

data/lib/composite_primary_keys/associations/collection_association.rb

@@ -1,32 +1,32 @@
-module CompositePrimaryKeys
-  module CollectionAssociation
-    def ids_writer(ids)
-      primary_key = reflection.association_primary_key
-      pk_type = klass.type_for_attribute(primary_key)
-      ids = Array(ids).reject(&:blank?)
-      ids.map! { |i| pk_type.cast(i) }
-
-      # CPK-
-      if primary_key.is_a?(Array)
-        predicate = CompositePrimaryKeys::Predicates.cpk_in_predicate(klass.arel_table, reflection.association_primary_key, ids)
-        records = klass.where(predicate).index_by do |r|
-          reflection.association_primary_key.map{ |k| r.send(k) }
-        end.values_at(*ids)
-      else
-        records = klass.where(primary_key => ids).index_by do |r|
-          r.public_send(primary_key)
-        end.values_at(*ids).compact
-      end
-
-      if records.size != ids.size
-        found_ids = records.map { |record| record.public_send(primary_key) }
-        not_found_ids = ids - found_ids
-        klass.all.raise_record_not_found_exception!(ids, records.size, ids.size, primary_key, not_found_ids)
-      else
-        replace(records)
-      end
-    end
-  end
-end
-
+module CompositePrimaryKeys
+  module CollectionAssociation
+    def ids_writer(ids)
+      primary_key = reflection.association_primary_key
+      pk_type = klass.type_for_attribute(primary_key)
+      ids = Array(ids).reject(&:blank?)
+      ids.map! { |i| pk_type.cast(i) }
+
+      # CPK-
+      if primary_key.is_a?(Array)
+        predicate = CompositePrimaryKeys::Predicates.cpk_in_predicate(klass.arel_table, reflection.association_primary_key, ids)
+        records = klass.where(predicate).index_by do |r|
+          reflection.association_primary_key.map{ |k| r.send(k) }
+        end.values_at(*ids)
+      else
+        records = klass.where(primary_key => ids).index_by do |r|
+          r.public_send(primary_key)
+        end.values_at(*ids).compact
+      end
+
+      if records.size != ids.size
+        found_ids = records.map { |record| record.public_send(primary_key) }
+        not_found_ids = ids - found_ids
+        klass.all.raise_record_not_found_exception!(ids, records.size, ids.size, primary_key, not_found_ids)
+      else
+        replace(records)
+      end
+    end
+  end
+end
+
 ActiveRecord::Associations::CollectionAssociation.prepend CompositePrimaryKeys::CollectionAssociation

data/lib/composite_primary_keys/associations/foreign_association.rb

@@ -1,15 +1,15 @@
-# frozen_string_literal: true
-
-module ActiveRecord::Associations
-  module ForeignAssociation # :nodoc:
-    def foreign_key_present?
-      if reflection.klass.primary_key
-        # CPK
-        # owner.attribute_present?(reflection.active_record_primary_key)
-        Array(reflection.active_record_primary_key).all? {|key| owner.attribute_present?(key)}
-      else
-        false
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module ActiveRecord::Associations
+  module ForeignAssociation # :nodoc:
+    def foreign_key_present?
+      if reflection.klass.primary_key
+        # CPK
+        # owner.attribute_present?(reflection.active_record_primary_key)
+        Array(reflection.active_record_primary_key).all? {|key| owner.attribute_present?(key)}
+      else
+        false
+      end
+    end
+  end
+end

data/lib/composite_primary_keys/associations/has_many_association.rb

@@ -1,35 +1,35 @@
-module ActiveRecord
-  module Associations
-    class HasManyAssociation
-      def delete_records(records, method)
-        if method == :destroy
-          records.each(&:destroy!)
-          update_counter(-records.length) unless reflection.inverse_updates_counter_cache?
-        # CPK
-        elsif self.reflection.klass.composite?
-          predicate = cpk_in_predicate(self.scope.table, self.reflection.klass.primary_keys, records.map(&:id))
-          scope = self.scope.where(predicate)
-          update_counter(-delete_count(method, scope))
-        else
-          scope = self.scope.where(reflection.klass.primary_key => records)
-          update_counter(-delete_count(method, scope))
-        end
-      end
-
-      def delete_count(method, scope)
-        if method == :delete_all
-          scope.delete_all
-        else
-          # CPK
-          # scope.update_all(nullified_owner_attributes)
-          conds = Array(reflection.foreign_key).inject(Hash.new) do |mem, key|
-            mem[key] = nil
-            mem
-          end
-          conds[reflection.type] = nil if reflection.type.present?
-          scope.update_all(conds)
-        end
-      end
-    end
-  end
-end
+module ActiveRecord
+  module Associations
+    class HasManyAssociation
+      def delete_records(records, method)
+        if method == :destroy
+          records.each(&:destroy!)
+          update_counter(-records.length) unless reflection.inverse_updates_counter_cache?
+        # CPK
+        elsif self.reflection.klass.composite?
+          predicate = cpk_in_predicate(self.scope.table, self.reflection.klass.primary_keys, records.map(&:id))
+          scope = self.scope.where(predicate)
+          update_counter(-delete_count(method, scope))
+        else
+          scope = self.scope.where(reflection.klass.primary_key => records)
+          update_counter(-delete_count(method, scope))
+        end
+      end
+
+      def delete_count(method, scope)
+        if method == :delete_all
+          scope.delete_all
+        else
+          # CPK
+          # scope.update_all(nullified_owner_attributes)
+          conds = Array(reflection.foreign_key).inject(Hash.new) do |mem, key|
+            mem[key] = nil
+            mem
+          end
+          conds[reflection.type] = nil if reflection.type.present?
+          scope.update_all(conds)
+        end
+      end
+    end
+  end
+end

data/lib/composite_primary_keys/associations/join_dependency.rb

@@ -1,103 +1,137 @@
-module ActiveRecord
-  module Associations
-    class JoinDependency
-      class Aliases # :nodoc:
-        def column_alias(node, column)
-          # CPK
-          #@alias_cache[node][column]
-          if column.kind_of?(Array)
-            column.map do |a_column|
-              @alias_cache[node][a_column]
-            end
-          else
-            @alias_cache[node][column]
-          end
-        end
-      end
-
-      def instantiate(result_set, &block)
-        primary_key = aliases.column_alias(join_root, join_root.primary_key)
-
-        seen = Hash.new { |i, object_id|
-          i[object_id] = Hash.new { |j, child_class|
-            j[child_class] = {}
-          }
-        }
-
-        model_cache = Hash.new { |h, klass| h[klass] = {} }
-        parents = model_cache[join_root]
-        column_aliases = aliases.column_aliases join_root
-
-        message_bus = ActiveSupport::Notifications.instrumenter
-
-        payload = {
-            record_count: result_set.length,
-            class_name: join_root.base_klass.name
-        }
-
-        message_bus.instrument("instantiation.active_record", payload) do
-          result_set.each { |row_hash|
-            # CPK
-            # parent_key = primary_key ? row_hash[primary_key] : row_hash
-            # CPK
-            parent_key = if primary_key.kind_of?(Array)
-                           primary_key.map {|key| row_hash[key]}
-                         else
-                           primary_key ? row_hash[primary_key] : row_hash
-                         end
-
-            parent = parents[parent_key] ||= join_root.instantiate(row_hash, column_aliases, &block)
-            construct(parent, join_root, row_hash, seen, model_cache)
-          }
-        end
-
-        parents.values
-      end
-
-      def construct(ar_parent, parent, row, seen, model_cache)
-        return if ar_parent.nil?
-
-        parent.children.each do |node|
-          if node.reflection.collection?
-            other = ar_parent.association(node.reflection.name)
-            other.loaded!
-          elsif ar_parent.association_cached?(node.reflection.name)
-            model = ar_parent.association(node.reflection.name).target
-            construct(model, node, row, seen, model_cache)
-            next
-          end
-
-          key = aliases.column_alias(node, node.primary_key)
-
-          # CPK
-          if key.is_a?(Array)
-            id = Array(key).map do |column_alias|
-              row[column_alias]
-            end
-            # At least the first value in the key has to be set.  Should we require all values to be set?
-            id = nil if id.first.nil?
-          else # original
-            id = row[key]
-          end
-
-          if id.nil? # duplicating this so it is clear what remained unchanged from the original
-            nil_association = ar_parent.association(node.reflection.name)
-            nil_association.loaded!
-            next
-          end
-
-          model = seen[ar_parent.object_id][node][id]
-
-          if model
-            construct(model, node, row, seen, model_cache)
-          else
-            model = construct_model(ar_parent, node, row, model_cache, id)
-
-            seen[ar_parent.object_id][node][id] = model
-            construct(model, node, row, seen, model_cache)
-          end
-        end
-      end
-    end
-  end
-end
+module ActiveRecord
+  module Associations
+    class JoinDependency
+
+      class JoinAssociation < JoinPart # :nodoc:
+        private
+          def append_constraints(join, constraints)
+            if join.is_a?(Arel::Nodes::StringJoin)
+              join_string = Arel::Nodes::And.new(constraints.unshift join.left)
+              join.left = Arel.sql(base_klass.connection.visitor.compile(join_string))
+            else
+              right = join.right
+              # CPK
+              if right.expr.children.empty?
+                right.expr = Arel::Nodes::And.new(constraints)
+              else
+                right.expr = Arel::Nodes::And.new(constraints.unshift right.expr)
+              end
+            end
+          end
+      end
+
+      class Aliases # :nodoc:
+        def column_alias(node, column)
+          # CPK
+          #@alias_cache[node][column]
+          if column.kind_of?(Array)
+            column.map do |a_column|
+              @alias_cache[node][a_column]
+            end
+          else
+            @alias_cache[node][column]
+          end
+        end
+      end
+
+      def instantiate(result_set, strict_loading_value, &block)
+        primary_key = aliases.column_alias(join_root, join_root.primary_key)
+
+        seen = Hash.new { |i, parent|
+          i[parent] = Hash.new { |j, child_class|
+            j[child_class] = {}
+          }
+        }.compare_by_identity
+
+        model_cache = Hash.new { |h, klass| h[klass] = {} }
+        parents = model_cache[join_root]
+
+        column_aliases = aliases.column_aliases(join_root)
+        column_names = []
+
+        result_set.columns.each do |name|
+          column_names << name unless /\At\d+_r\d+\z/.match?(name)
+        end
+
+        if column_names.empty?
+          column_types = {}
+        else
+          column_types = result_set.column_types
+          unless column_types.empty?
+            attribute_types = join_root.attribute_types
+            column_types = column_types.slice(*column_names).delete_if { |k, _| attribute_types.key?(k) }
+          end
+          column_aliases += column_names.map! { |name| Aliases::Column.new(name, name) }
+        end
+
+        message_bus = ActiveSupport::Notifications.instrumenter
+
+        payload = {
+          record_count: result_set.length,
+          class_name: join_root.base_klass.name
+        }
+
+        message_bus.instrument("instantiation.active_record", payload) do
+          result_set.each { |row_hash|
+            # CPK
+            # parent_key = primary_key ? row_hash[primary_key] : row_hash
+            parent_key = if primary_key.kind_of?(Array)
+                           primary_key.map {|key| row_hash[key]}
+                         else
+                           primary_key ? row_hash[primary_key] : row_hash
+                         end
+
+            parent = parents[parent_key] ||= join_root.instantiate(row_hash, column_aliases, column_types, &block)
+            construct(parent, join_root, row_hash, seen, model_cache, strict_loading_value)
+          }
+        end
+
+        parents.values
+      end
+
+      def construct(ar_parent, parent, row, seen, model_cache, strict_loading_value)
+        return if ar_parent.nil?
+
+        parent.children.each do |node|
+          if node.reflection.collection?
+            other = ar_parent.association(node.reflection.name)
+            other.loaded!
+          elsif ar_parent.association_cached?(node.reflection.name)
+            model = ar_parent.association(node.reflection.name).target
+            construct(model, node, row, seen, model_cache, strict_loading_value)
+            next
+          end
+
+          key = aliases.column_alias(node, node.primary_key)
+          # CPK
+          if key.is_a?(Array)
+            id = Array(key).map do |column_alias|
+              row[column_alias]
+            end
+            # At least the first value in the key has to be set.  Should we require all values to be set?
+            id = nil if id.first.nil?
+          else # original
+            id = row[key]
+          end
+
+          if id.nil?
+            nil_association = ar_parent.association(node.reflection.name)
+            nil_association.loaded!
+            next
+          end
+
+          model = seen[ar_parent][node][id]
+
+          if model
+            construct(model, node, row, seen, model_cache, strict_loading_value)
+          else
+            model = construct_model(ar_parent, node, row, model_cache, id, strict_loading_value)
+
+            seen[ar_parent][node][id] = model
+            construct(model, node, row, seen, model_cache, strict_loading_value)
+          end
+        end
+      end
+    end
+  end
+end