composite_primary_keys 7.0.16 → 8.0.0

data/lib/composite_primary_keys/associations/has_many_through_association.rb

@@ -16,12 +16,7 @@ module ActiveRecord
       def delete_records(records, method)
         ensure_not_nested
 
-        # This is unoptimised; it will load all the target records
-        # even when we just want to delete everything.
-        records = load_target if records == :all
-
         scope = through_association.scope
-
         # CPK
         # scope.where! construct_join_attributes(*records)
         if source_reflection.klass.composite?
@@ -31,26 +26,26 @@ module ActiveRecord
         end
 
         case method
-          when :destroy
-            if scope.klass.primary_key
-              count = scope.destroy_all.length
-            else
-              scope.to_a.each do |record|
-                record.run_callbacks :destroy
-              end
+        when :destroy
+          if scope.klass.primary_key
+            count = scope.destroy_all.length
+          else
+            scope.to_a.each do |record|
+              record.run_callbacks :destroy
+            end
 
-              arel = scope.arel
+            arel = scope.arel
 
-              stmt = Arel::DeleteManager.new arel.engine
-              stmt.from scope.klass.arel_table
-              stmt.wheres = arel.constraints
+            stmt = Arel::DeleteManager.new arel.engine
+            stmt.from scope.klass.arel_table
+            stmt.wheres = arel.constraints
 
-              count = scope.klass.connection.delete(stmt, 'SQL', scope.bind_values)
-            end
-          when :nullify
-            count = scope.update_all(source_reflection.foreign_key => nil)
-          else
-            count = scope.delete_all
+            count = scope.klass.connection.delete(stmt, 'SQL', scope.bind_values)
+          end
+        when :nullify
+          count = scope.update_all(source_reflection.foreign_key => nil)
+        else
+          count = scope.delete_all
         end
 
         delete_through_records(records)
@@ -60,7 +55,7 @@ module ActiveRecord
           klass.decrement_counter counter, records.map(&:id)
         end
 
-        if through_reflection.macro == :has_many && update_through_counter?(method)
+        if through_reflection.collection? && update_through_counter?(method)
           update_counter(-count, through_reflection)
         end
 
@@ -69,17 +64,24 @@ module ActiveRecord
 
       def through_records_for(record)
         # CPK
-        #attributes = construct_join_attributes(record)
-        #candidates = Array.wrap(through_association.target)
-        #candidates.find_all { |c| c.attributes.slice(*attributes.keys) == attributes }
-
+        # attributes = construct_join_attributes(record)
+        # candidates = Array.wrap(through_association.target)
+        # candidates.find_all do |c|
+        #   attributes.all? do |key, value|
+        #     c.public_send(key) == value
+        #   end
+        # end
         if record.composite?
           candidates = Array.wrap(through_association.target)
           candidates.find_all { |c| c.attributes.slice(*source_reflection.association_primary_key) == record.ids_hash }
         else
           attributes = construct_join_attributes(record)
           candidates = Array.wrap(through_association.target)
-          candidates.find_all { |c| c.attributes.slice(*attributes.keys) == attributes }
+          candidates.find_all do |c|
+            attributes.all? do |key, value|
+              c.public_send(key) == value
+            end
+          end
         end
       end
 

data/lib/composite_primary_keys/associations/join_dependency.rb

@@ -1,89 +1,87 @@
-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, aliases)
-        primary_key = aliases.column_alias(join_root, join_root.primary_key)
-        type_caster = result_set.column_type primary_key
-
-        seen = Hash.new { |h,parent_klass|
-          h[parent_klass] = Hash.new { |i,parent_id|
-            i[parent_id] = Hash.new { |j,child_klass| j[child_klass] = {} }
-          }
-        }
-
-        model_cache = Hash.new { |h,klass| h[klass] = {} }
-        parents = model_cache[join_root]
-        column_aliases = aliases.column_aliases join_root
-
-        result_set.each { |row_hash|
-          # CPK
-          #primary_id = type_caster.type_cast row_hash[primary_key]
-          primary_id = if primary_key.kind_of?(Array)
-                         primary_key.map {|key| type_caster.type_cast row_hash[key]}
-                       else
-                         type_caster.type_cast row_hash[primary_key]
-                       end
-          parent = parents[primary_id] ||= join_root.instantiate(row_hash, column_aliases)
-          construct(parent, join_root, row_hash, result_set, seen, model_cache, aliases)
-        }
-
-        parents.values
-      end
-
-      def construct(ar_parent, parent, row, rs, seen, model_cache, aliases)
-        primary_id  = ar_parent.id
-
-        parent.children.each do |node|
-          if node.reflection.collection?
-            other = ar_parent.association(node.reflection.name)
-            other.loaded!
-          else
-            if ar_parent.association_cache.key?(node.reflection.name)
-              model = ar_parent.association(node.reflection.name).target
-              construct(model, node, row, rs, seen, model_cache, aliases)
-              next
-            end
-          end
-
-          key = aliases.column_alias(node, node.primary_key)
-
-          # CPK
-          if key.is_a?(Array)
-            id = Array(key).map do |column_alias|
-              value = row[column_alias]
-            end
-            # At least the first value in the key has to be set.  Should we require all values to be set?
-            next if id.first.nil?
-          else
-            id = row[key]
-            next if id.nil?
-          end
-
-          model = seen[parent.base_klass][primary_id][node.base_klass][id]
-
-          if model
-            construct(model, node, row, rs, seen, model_cache, aliases)
-          else
-            model = construct_model(ar_parent, node, row, model_cache, id, aliases)
-            seen[parent.base_klass][primary_id][node.base_klass][id] = model
-            construct(model, node, row, rs, seen, model_cache, aliases)
-          end
-        end
-      end
-    end
-  end
-end
+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, aliases)
+        primary_key = aliases.column_alias(join_root, join_root.primary_key)
+
+        seen = Hash.new { |h,parent_klass|
+          h[parent_klass] = Hash.new { |i,parent_id|
+            i[parent_id] = Hash.new { |j,child_klass| j[child_klass] = {} }
+          }
+        }
+
+        model_cache = Hash.new { |h,klass| h[klass] = {} }
+        parents = model_cache[join_root]
+        column_aliases = aliases.column_aliases join_root
+
+        result_set.each { |row_hash|
+          # CPK
+          primary_id = if primary_key.kind_of?(Array)
+                         primary_key.map {|key| row_hash[key]}
+                       else
+                         row_hash[primary_key]
+                       end
+          parent = parents[primary_id] ||= join_root.instantiate(row_hash, column_aliases)
+          construct(parent, join_root, row_hash, result_set, seen, model_cache, aliases)
+        }
+
+        parents.values
+      end
+
+      def construct(ar_parent, parent, row, rs, seen, model_cache, aliases)
+        primary_id  = ar_parent.id
+
+        parent.children.each do |node|
+          if node.reflection.collection?
+            other = ar_parent.association(node.reflection.name)
+            other.loaded!
+          else
+            if ar_parent.association_cache.key?(node.reflection.name)
+              model = ar_parent.association(node.reflection.name).target
+              construct(model, node, row, rs, seen, model_cache, aliases)
+              next
+            end
+          end
+
+          key = aliases.column_alias(node, node.primary_key)
+
+          # CPK
+          if key.is_a?(Array)
+            id = Array(key).map do |column_alias|
+              value = row[column_alias]
+            end
+            # At least the first value in the key has to be set.  Should we require all values to be set?
+            next if id.first.nil?
+          else
+            id = row[key]
+            next if id.nil?
+          end
+
+          model = seen[parent.base_klass][primary_id][node.base_klass][id]
+
+          if model
+            construct(model, node, row, rs, seen, model_cache, aliases)
+          else
+            model = construct_model(ar_parent, node, row, model_cache, id, aliases)
+            seen[parent.base_klass][primary_id][node.base_klass][id] = model
+            construct(model, node, row, rs, seen, model_cache, aliases)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/composite_primary_keys/associations/join_dependency/join_association.rb

@@ -1,22 +1,22 @@
-module ActiveRecord
-  module Associations
-    class JoinDependency
-      class JoinAssociation
-        def build_constraint(klass, table, key, foreign_table, foreign_key)
-          # CPK
-          # constraint = table[key].eq(foreign_table[foreign_key])
-          constraint = cpk_join_predicate(table, key, foreign_table, foreign_key)
-
-          if klass.finder_needs_type_condition?
-            constraint = table.create_and([
-              constraint,
-              klass.send(:type_condition, table)
-            ])
-          end
-
-          constraint
-        end
-      end
-    end
-  end
-end
+module ActiveRecord
+  module Associations
+    class JoinDependency
+      class JoinAssociation
+        def build_constraint(klass, table, key, foreign_table, foreign_key)
+          # CPK
+          # constraint = table[key].eq(foreign_table[foreign_key])
+          constraint = cpk_join_predicate(table, key, foreign_table, foreign_key)
+
+          if klass.finder_needs_type_condition?
+            constraint = table.create_and([
+              constraint,
+              klass.send(:type_condition, table)
+            ])
+          end
+
+          constraint
+        end
+      end
+    end
+  end
+end

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

@@ -1,78 +1,90 @@
-module ActiveRecord
-  module Associations
-    class Preloader
-      class Association
-        def query_scope(ids)
-          # CPK
-          # scope.where(association_key.in(ids))
-
-          if reflection.foreign_key.is_a?(Array)
-            predicate = cpk_in_predicate(table, reflection.foreign_key, ids)
-            scope.where(predicate)
-          else
-            scope.where(association_key.in(ids))
-          end
-        end
-
-        def associated_records_by_owner(preloader)
-          # CPK
-          owners_map = owners_by_key
-          #owner_keys = owners_map.keys.compact
-          owner_keys = owners.map do |owner|
-            Array(owner_key_name).map do |owner_key|
-              owner[owner_key]
-            end
-          end.compact.uniq
-
-          # Each record may have multiple owners, and vice-versa
-          records_by_owner = owners.each_with_object({}) do |owner,h|
-            h[owner] = []
-          end
-
-          if owner_keys.any?
-            # Some databases impose a limit on the number of ids in a list (in Oracle it's 1000)
-            # Make several smaller queries if necessary or make one query if the adapter supports it
-            sliced  = owner_keys.each_slice(klass.connection.in_clause_length || owner_keys.size)
-
-            records = load_slices sliced
-            records.each do |record, owner_key|
-              owners_map[owner_key].each do |owner|
-                records_by_owner[owner] << record
-              end
-            end
-          end
-
-          records_by_owner
-        end
-
-        def load_slices(slices)
-          @preloaded_records = slices.flat_map { |slice|
-            records_for(slice)
-          }
-
-          @preloaded_records.map { |record|
-            # CPK
-            #[record, record[association_key_name]]
-            owner_key = Array(association_key_name).map do |key_name|
-              record[key_name]
-            end.join(CompositePrimaryKeys::ID_SEP)
-            [record, owner_key]
-          }
-        end
-
-        def owners_by_key
-          @owners_by_key ||= owners.group_by do |owner|
-            # CPK
-            # key = owner[owner_key_name]
-            key = Array(owner_key_name).map do |key_name|
-              owner[key_name]
-            end
-            # CPK
-            # key && key.to_s
-            key && key.join(CompositePrimaryKeys::ID_SEP)
-          end
-        end
-      end
-    end
-  end
-end
+module ActiveRecord
+  module Associations
+    class Preloader
+      class Association
+        def query_scope(ids)
+          # CPK
+          # scope.where(association_key.in(ids))
+
+          if reflection.foreign_key.is_a?(Array)
+            predicate = cpk_in_predicate(table, reflection.foreign_key, ids)
+            scope.where(predicate)
+          else
+            scope.where(association_key.in(ids))
+          end
+        end
+
+        def associated_records_by_owner(preloader)
+          owners_map = owners_by_key
+          # CPK
+          # owner_keys = owners_map.keys.compact
+          owner_keys = if reflection.foreign_key.is_a?(Array)
+            owners.map do |owner|
+              Array(owner_key_name).map do |owner_key|
+                owner[owner_key]
+              end
+            end.compact.uniq
+          else
+            owners_map.keys.compact
+          end
+
+          # Each record may have multiple owners, and vice-versa
+          records_by_owner = owners.each_with_object({}) do |owner,h|
+            h[owner] = []
+          end
+
+          if owner_keys.any?
+            # Some databases impose a limit on the number of ids in a list (in Oracle it's 1000)
+            # Make several smaller queries if necessary or make one query if the adapter supports it
+            sliced  = owner_keys.each_slice(klass.connection.in_clause_length || owner_keys.size)
+
+            records = load_slices sliced
+            records.each do |record, owner_key|
+              owners_map[owner_key].each do |owner|
+                records_by_owner[owner] << record
+              end
+            end
+          end
+
+          records_by_owner
+        end
+
+        def load_slices(slices)
+          @preloaded_records = slices.flat_map { |slice|
+            records_for(slice)
+          }
+
+          @preloaded_records.map { |record|
+            # CPK
+            #[record, record[association_key_name]]
+            owner_key = Array(association_key_name).map do |key_name|
+              record[key_name]
+            end.join(CompositePrimaryKeys::ID_SEP)
+            [record, owner_key]
+          }
+        end
+
+        def owners_by_key
+          @owners_by_key ||= if key_conversion_required?
+                               owners.group_by do |owner|
+                                 # CPK
+                                 # owner[owner_key_name].to_s
+                                 key = Array(owner_key_name).map do |key_name|
+                                   owner[key_name]
+                                 end.join(CompositePrimaryKeys::ID_SEP)
+                               end
+                             else
+                               owners.group_by do |owner|
+                                 # CPK
+                                 # owner[owner_key_name]
+                                 key = Array(owner_key_name).map do |key_name|
+                                   owner[key_name]
+                                 end.join(CompositePrimaryKeys::ID_SEP)
+                               end
+                             end
+                             
+        end
+      end
+    end
+  end
+end