composite_primary_keys 13.0.8 → 14.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8604d48445aede0e7f6d39ad32090ea2ed0f8d7cd58ab633a3d0c013ee1ab3b8
-  data.tar.gz: a71f857e9125065b7c635170c341ce4a9285f6942c8989dac9cfa201f428a062
+  metadata.gz: 4310258f29b867cf484cb8dbebfe1f7a7d41810f2dac5f90049c534f1c0a908b
+  data.tar.gz: 970906ceae8ac95925d5ee694541b09844f3104309eaed5864f9b1faff7fb43e
 SHA512:
-  metadata.gz: fb13f66165419e9ca60e9b1b3283ff174947d3d2d07d1b7e29a62cb0feae97bbe5abc3179d41f330f76d2837d27c837875a01039f1c9e2969769293c4617b7d2
-  data.tar.gz: 14790bef238c5f4e6360a5613db1bd22e3333bc06a062bc6047212b077d02828bb6d1acdda436f8a4106bc1e82dc6fe4ef96d2e05f5f3dd72beb86bf0c4ae0a1
+  metadata.gz: 78878c2b2fa9612e8e141b5b1d39679a03046aed63e7c19e7ad71b6b8372327cfcb9a5bb659d88fda5cbb405e5bf7199c742b0468041a9509406ce54764d4e10
+  data.tar.gz: 79e78cb7cf9a336821cb02dad8d1cf43aece81e25b18c4ebadac1b584be1d6bd06a7a43b7840c918323efb69d8b0c9783c215595f04a37dc083079ba4e0cc50e

data/History.rdoc

@@ -1,34 +1,15 @@
-== 13.0.8 (2023-11-24)
-Fix `polymorphic_name` support (Vladimir Kochnev)
+== 14.0.1 (2022-01-9)
+* Fix mistake in Gemfile (Charlie Savage)
 
-== 13.0.7 (2023-02-04)
-* Fix #573 (Charlie Savage)
-
-== 13.0.6 (2023-02-04)
-* Fix #577 (Charlie Savage)
-
-== 13.0.5 (2023-02-04)
-* Improve query generation for cpk_in_predicate. This reduces the length of
-queries when loading many keys and enables Postgres to use index scans
-more frequently. (Andrew Kiellor)
-
-== 13.0.4 (2022-12-05)
-* Fix previously_new_record? not being set to true after create
-
-== 13.0.3 (2022-01-09)
-* Remove override on ActiveRecord::Base#to_param. That method has moved to Integration
-  so no longer works. #541. (Charlie Savage)
-* Check if an assocation is polymorhpic. Fixes #558.
-
-== 13.0.2 (2022-01-09)
-* Fix scoped associations take #2 (Charlie Savage)
+== 14.0.0 (2022-01-9)
+* Update to ActiveRecord 7.0 (Sammy Larbi)
 
 == 13.0.1 (2021-11-14)
 * Fix invalid sql generation for some cases of scoped associations (Ryan Mulligan)
 * Fix unintentional connection to database (Kazuhiro Masuda)
 * Zip values then keys - fixes #548 (Charlie Savage)
 
-== 13.0.0 (2021-05-09)
+== 13.0.0 (2021-5-9)
 * Update to ActiveRecord 6.1 (Javier Julio, Charlie Savage, Sammy Larbi)
 
 == 12.0.10 (2021-05-09)

data/README.rdoc

@@ -20,6 +20,7 @@ Every major version of ActiveRecord has included numerous internal changes.  As
 CPK has to be rewritten for each version of ActiveRecord.  To help keep
 things straight, here is the mapping:
 
+    Version 14.x is designed to work with ActiveRecord 7.0.x
     Version 13.x is designed to work with ActiveRecord 6.1.x
     Version 12.x is designed to work with ActiveRecord 6.0.x
     Version 11.x is designed to work with ActiveRecord 5.2.x

data/lib/composite_primary_keys/associations/association.rb

@@ -11,8 +11,8 @@ module ActiveRecord
             attributes[key1] = owner[key2]
           end
 
-          if reflection.type
-            attributes[reflection.type] = owner.class.polymorphic_name
+          if reflection.options[:as]
+            attributes[reflection.type] = owner.class.base_class.name
           end
         end
 

data/lib/composite_primary_keys/associations/association_scope.rb

@@ -64,4 +64,4 @@ module ActiveRecord
       end
     end
   end
-end
+end

data/lib/composite_primary_keys/associations/{join_association.rb → join_dependency.rb}

@@ -1,137 +1,137 @@
-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.is_a?(Arel::Nodes::And) && 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
+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

data/lib/composite_primary_keys/associations/preloader/association.rb

@@ -2,6 +2,20 @@ module ActiveRecord
   module Associations
     class Preloader
       class Association
+
+        class LoaderQuery
+          def load_records_for_keys(keys, &block)
+            # CPK
+            if association_key_name.is_a?(Array)
+              predicate = cpk_in_predicate(scope.klass.arel_table, association_key_name, keys)
+              scope.where(predicate).load(&block)
+            else
+              scope.where(association_key_name => keys).load(&block)
+            end
+          end
+        end
+
+        # TODO: is records_for needed anymore? Rails' implementation has changed significantly
         def records_for(ids)
           records = if association_key_name.is_a?(Array)
                       predicate = cpk_in_predicate(klass.arel_table, association_key_name, ids)
@@ -33,28 +47,21 @@ module ActiveRecord
           end
         end
 
-        def load_records
-          # owners can be duplicated when a relation has a collection association join
-          # #compare_by_identity makes such owners different hash keys
-          @records_by_owner = {}.compare_by_identity
-          raw_records = owner_keys.empty? ? [] : records_for(owner_keys)
-
-          @preloaded_records = raw_records.select do |record|
-            assignments = false
-
-            owners_by_key[convert_key(record[association_key_name])].each do |owner|
-              entries = (@records_by_owner[owner] ||= [])
-
-              if reflection.collection? || entries.empty?
-                entries << record
-                assignments = true
-              end
+        # TODO: is records_by_owner needed anymore? Rails' implementation has changed significantly
+        def records_by_owner
+          @records_by_owner ||= preloaded_records.each_with_object({}) do |record, result|
+            key = if association_key_name.is_a?(Array)
+                    Array(record[association_key_name]).map do |key|
+                      convert_key(key)
+                    end
+                  else
+                    convert_key(record[association_key_name])
+                  end
+            owners_by_key[key].each do |owner|
+              (result[owner] ||= []) << record
             end
-
-            assignments
           end
         end
-
       end
     end
   end

data/lib/composite_primary_keys/associations/through_association.rb

@@ -5,7 +5,8 @@ module ActiveRecord
 
       def construct_join_attributes(*records)
         # CPK
-        if !self.source_reflection.polymorphic? && source_reflection.klass.composite?
+        is_composite = self.source_reflection.polymorphic? ? source_reflection.active_record.composite? : source_reflection.klass.composite?
+        if is_composite
           ensure_mutable
 
           ids = records.map do |record|