composite_primary_keys 8.1.8 → 9.0.0.beta1

data/lib/composite_primary_keys/associations/has_many_through_association.rb

@@ -13,79 +13,79 @@ module ActiveRecord
         cpk_in_predicate(through_association.scope.klass.arel_table, source_reflection.foreign_key, ids)
       end
 
-      def delete_records(records, method)
-        ensure_not_nested
+      silence_warnings do
+        def delete_records(records, method)
+          ensure_not_nested
 
-        scope = through_association.scope
-        # CPK
-        # scope.where! construct_join_attributes(*records)
-        source_klass = source_reflection.polymorphic? ? klass : source_reflection.klass
-        if source_klass.composite?
-          scope.where! cpk_join_through_predicate(*records)
-        else
-          scope.where! construct_join_attributes(*records)
-        end
-
-        case method
-        when :destroy
-          if scope.klass.primary_key
-            count = scope.destroy_all.length
+          scope = through_association.scope
+          # CPK
+          # scope.where! construct_join_attributes(*records)
+          if source_reflection.klass.composite?
+            scope.where! cpk_join_through_predicate(*records)
           else
-            scope.to_a.each do |record|
-              record.run_callbacks :destroy
-            end
+            scope.where! construct_join_attributes(*records)
+          end
 
-            arel = scope.arel
+          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
 
-            stmt = Arel::DeleteManager.new arel.engine
-            stmt.from scope.klass.arel_table
-            stmt.wheres = arel.constraints
+              arel = scope.arel
 
-            count = scope.klass.connection.delete(stmt, 'SQL', scope.bind_values)
+              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
           end
-        when :nullify
-          count = scope.update_all(source_reflection.foreign_key => nil)
-        else
-          count = scope.delete_all
-        end
 
-        delete_through_records(records)
+          delete_through_records(records)
 
-        if source_reflection.options[:counter_cache] && method != :destroy
-          counter = source_reflection.counter_cache_column
-          klass.decrement_counter counter, records.map(&:id)
-        end
+          if source_reflection.options[:counter_cache] && method != :destroy
+            counter = source_reflection.counter_cache_column
+            klass.decrement_counter counter, records.map(&:id)
+          end
 
-        if through_reflection.collection? && update_through_counter?(method)
-          update_counter(-count, through_reflection)
-        end
+          if through_reflection.collection? && update_through_counter?(method)
+            update_counter(-count, through_reflection)
+          end
 
-        update_counter(-count)
-      end
+          update_counter(-count)
+        end
 
-      def through_records_for(record)
-        # CPK
-        # 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 do |c|
-            attributes.all? do |key, value|
-              c.public_send(key) == value
+        def through_records_for(record)
+          # CPK
+          # 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 do |c|
+              attributes.all? do |key, value|
+                c.public_send(key) == value
+              end
             end
           end
         end
       end
-
     end
   end
 end

data/lib/composite_primary_keys/associations/join_dependency.rb

@@ -2,83 +2,101 @@ 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]
+        silence_warnings do
+          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
-          else
-            @alias_cache[node][column]
           end
         end
       end
 
-      def instantiate(result_set, aliases)
-        primary_key = aliases.column_alias(join_root, join_root.primary_key)
+      silence_warnings do
+        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] = {} }
+          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
+          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)
-        }
+          message_bus = ActiveSupport::Notifications.instrumenter
 
-        parents.values
-      end
+          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 = 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)
+              construct(parent, join_root, row_hash, result_set, seen, model_cache, aliases)
+            }
+          end
+
+          parents.values
+        end
 
-      def construct(ar_parent, parent, row, rs, seen, model_cache, aliases)
-        primary_id  = ar_parent.id
+        def construct(ar_parent, parent, row, rs, seen, model_cache, aliases)
+          return if ar_parent.nil?
 
-        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)
+          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, rs, seen, model_cache, aliases)
               next
             end
-          end
 
-          key = aliases.column_alias(node, node.primary_key)
+            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]
+            # 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
-            # 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]
+            model = seen[ar_parent.object_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)
+            if model
+              construct(model, node, row, rs, seen, model_cache, aliases)
+            else
+              model = construct_model(ar_parent, node, row, model_cache, id, aliases)
+              model.readonly!
+              seen[ar_parent.object_id][node.base_klass][id] = model
+              construct(model, node, row, rs, seen, model_cache, aliases)
+            end
           end
         end
       end

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

@@ -2,19 +2,21 @@ 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)
+        silence_warnings do
+          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
+            if klass.finder_needs_type_condition?
+              constraint = table.create_and([
+                constraint,
+                klass.send(:type_condition, table)
+              ])
+            end
 
-          constraint
+            constraint
+          end
         end
       end
     end

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

@@ -2,92 +2,95 @@ module ActiveRecord
   module Associations
     class Preloader
       class Association
-        def query_scope(ids)
-          # CPK
-          # scope.where(association_key.in(ids))
+        silence_warnings do
+          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))
+            if reflection.foreign_key.is_a?(Array)
+              predicate = cpk_in_predicate(table, reflection.foreign_key, ids)
+              scope.where(predicate)
+            else
+              scope.where(association_key_name => ids)
+            end
           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
+          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
+            # 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)
+            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
+              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
-          end
 
-          records_by_owner
-        end
+            records_by_owner
+          end
 
-        def load_slices(slices)
-          @preloaded_records = slices.flat_map { |slice|
-            records_for(slice)
-          }
+          def load_slices(slices)
+            @preloaded_records = slices.flat_map { |slice|
+              records_for(slice)
+            }
 
-          # CPK
-          # @preloaded_records.map { |record|
-          #   key = record[association_key_name]
-          #   key = key.to_s if key_conversion_required?
-          #
-          #   [record, key]
-          # }
-          @preloaded_records.map { |record|
-            key = Array(association_key_name).map do |key_name|
-              record[key_name]
-            end.to_composite_keys.to_s
+            # CPK
+            # @preloaded_records.map { |record|
+            #   key = record[association_key_name]
+            #   key = key.to_s if key_conversion_required?
+            #
+            #   [record, key]
+            # }
+            @preloaded_records.map { |record|
+              key = Array(association_key_name).map do |key_name|
+                record[key_name]
+              end.join(CompositePrimaryKeys::ID_SEP)
 
-            [record, key]
-          }
-        end
+              [record, 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
-                                 Array(owner_key_name).map do |key_name|
-                                   owner[key_name]
-                                 end.to_composite_keys.to_s
+          def owners_by_key
+            @owners_by_key ||= if key_conversion_required?
+                                 owners.group_by do |owner|
+                                   # CPK
+                                   # owner[owner_key_name].to_s
+                                   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]
+                                   Array(owner_key_name).map do |key_name|
+                                     owner[key_name]
+                                   end.join(CompositePrimaryKeys::ID_SEP)
+                                 end
                                end
-                             else
-                               owners.group_by do |owner|
-                                 # CPK
-                                 # owner[owner_key_name]
-                                 Array(owner_key_name).map do |key_name|
-                                   owner[key_name]
-                                 end.to_composite_keys.to_s
-                               end
-                             end
+
+          end
         end
       end
     end