composite_primary_keys 7.0.13 → 7.0.14

data/lib/composite_primary_keys/associations/has_many_association.rb

@@ -1,56 +1,56 @@
-module ActiveRecord
-  module Associations
-    class HasManyAssociation
-      def delete_records(records, method)
-        if method == :destroy
-          records.each(&:destroy!)
-          update_counter(-records.length) unless inverse_updates_counter_cache?
-        else
-          if records == :all || !reflection.klass.primary_key
-            scope = self.scope
-          else
-            # CPK
-            # scope = self.scope.where(reflection.klass.primary_key => records)
-            table = Arel::Table.new(reflection.table_name)
-            and_conditions = records.map do |record|
-              eq_conditions = Array(reflection.association_primary_key).map do |name|
-                table[name].eq(record[name])
-              end
-              Arel::Nodes::And.new(eq_conditions)
-            end
-
-            condition = and_conditions.shift
-            and_conditions.each do |and_condition|
-              condition = condition.or(and_condition)
-            end
-
-            scope = self.scope.where(condition)
-          end
-
-          if method == :delete_all
-            update_counter(-scope.delete_all)
-          else
-            # CPK
-            # update_counter(-scope.update_all(reflection.foreign_key => nil))
-            update_hash = Array(reflection.foreign_key).inject(Hash.new) do |hash, key|
-              hash[key] = nil
-              hash
-            end
-            update_counter(-scope.update_all(update_hash))
-          end
-        end
-      end
-
-      def foreign_key_present?
-        if reflection.klass.primary_key
-          # CPK
-          #owner.attribute_present?(reflection.association_primary_key)
-          owner.attribute_present?(reflection.association_primary_key)
-          Array(reflection.klass.primary_key).all? {|key| owner.attribute_present?(key)}
-        else
-          false
-        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 inverse_updates_counter_cache?
+        else
+          if records == :all || !reflection.klass.primary_key
+            scope = self.scope
+          else
+            # CPK
+            # scope = self.scope.where(reflection.klass.primary_key => records)
+            table = Arel::Table.new(reflection.table_name)
+            and_conditions = records.map do |record|
+              eq_conditions = Array(reflection.association_primary_key).map do |name|
+                table[name].eq(record[name])
+              end
+              Arel::Nodes::And.new(eq_conditions)
+            end
+
+            condition = and_conditions.shift
+            and_conditions.each do |and_condition|
+              condition = condition.or(and_condition)
+            end
+
+            scope = self.scope.where(condition)
+          end
+
+          if method == :delete_all
+            update_counter(-scope.delete_all)
+          else
+            # CPK
+            # update_counter(-scope.update_all(reflection.foreign_key => nil))
+            update_hash = Array(reflection.foreign_key).inject(Hash.new) do |hash, key|
+              hash[key] = nil
+              hash
+            end
+            update_counter(-scope.update_all(update_hash))
+          end
+        end
+      end
+
+      def foreign_key_present?
+        if reflection.klass.primary_key
+          # CPK
+          #owner.attribute_present?(reflection.association_primary_key)
+          owner.attribute_present?(reflection.association_primary_key)
+          Array(reflection.klass.primary_key).all? {|key| owner.attribute_present?(key)}
+        else
+          false
+        end
+      end
+    end
+  end
+end

data/lib/composite_primary_keys/associations/join_dependency.rb

@@ -1,89 +1,89 @@
-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)
+        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

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

@@ -1,39 +1,39 @@
-module ActiveRecord
-  module Associations
-    class JoinDependency
-      class JoinPart
-        def aliased_primary_key
-          # CPK
-          # "#{aliased_prefix}_r0"
-
-          base_klass.composite? ?
-            primary_key.inject([]) {|aliased_keys, key| aliased_keys << "#{ aliased_prefix }_r#{aliased_keys.length}"} :
-            "#{ aliased_prefix }_r0"
-        end
-
-        def record_id(row)
-          # CPK
-          # row[aliased_primary_key]
-          base_klass.composite? ?
-            aliased_primary_key.map {|key| row[key]}.to_composite_keys :
-            row[aliased_primary_key]
-        end
-
-        def column_names_with_alias
-          unless @column_names_with_alias
-            @column_names_with_alias = []
-
-            # CPK
-            #([primary_key] + (column_names - [primary_key])).each_with_index do |column_name, i|
-            keys = base_klass.composite? ? primary_key.map(&:to_s) : [primary_key]
-
-            (keys + (column_names - keys)).each_with_index do |column_name, i|
-              @column_names_with_alias << [column_name, "#{aliased_prefix}_r#{i}"]
-            end
-          end
-          @column_names_with_alias
-        end
-      end
-    end
-  end
+module ActiveRecord
+  module Associations
+    class JoinDependency
+      class JoinPart
+        def aliased_primary_key
+          # CPK
+          # "#{aliased_prefix}_r0"
+
+          base_klass.composite? ?
+            primary_key.inject([]) {|aliased_keys, key| aliased_keys << "#{ aliased_prefix }_r#{aliased_keys.length}"} :
+            "#{ aliased_prefix }_r0"
+        end
+
+        def record_id(row)
+          # CPK
+          # row[aliased_primary_key]
+          base_klass.composite? ?
+            aliased_primary_key.map {|key| row[key]}.to_composite_keys :
+            row[aliased_primary_key]
+        end
+
+        def column_names_with_alias
+          unless @column_names_with_alias
+            @column_names_with_alias = []
+
+            # CPK
+            #([primary_key] + (column_names - [primary_key])).each_with_index do |column_name, i|
+            keys = base_klass.composite? ? primary_key.map(&:to_s) : [primary_key]
+
+            (keys + (column_names - keys)).each_with_index do |column_name, i|
+              @column_names_with_alias << [column_name, "#{aliased_prefix}_r#{i}"]
+            end
+          end
+          @column_names_with_alias
+        end
+      end
+    end
+  end
 end

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

@@ -1,78 +1,78 @@
-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)
+          # 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