composite_primary_keys 12.0.10 → 13.0.3

data/lib/composite_primary_keys/nested_attributes.rb

@@ -70,7 +70,7 @@ module ActiveRecord
             if target_record
               existing_record = target_record
             else
-              association.add_to_target(existing_record, :skip_callbacks)
+              association.add_to_target(existing_record, skip_callbacks: true)
             end
 
             assign_to_or_mark_for_destruction(existing_record, attributes, options[:allow_destroy])

data/lib/composite_primary_keys/persistence.rb

@@ -1,82 +1,82 @@
-module ActiveRecord
-  module Persistence
-    module ClassMethods
-      def delete(id_or_array)
-        # CPK
-        if self.composite?
-          id_or_array = if id_or_array.is_a?(CompositePrimaryKeys::CompositeKeys)
-                          [id_or_array]
-                        else
-                          Array(id_or_array)
-                        end
-
-          # Delete should return the number of deleted records
-          id_or_array.map do |id|
-            # Is the passed in id actually a record?
-            id = id.kind_of?(::ActiveRecord::Base) ? id.id : id
-            delete_by(cpk_id_predicate(self.arel_table, self.primary_key, id))
-          end.sum
-        else
-          delete_by(primary_key => id_or_array)
-        end
-      end
-
-      def _update_record(values, constraints) # :nodoc:
-        # CPK
-        if self.composite? && constraints[primary_key]
-          primary_key_values = constraints.delete(primary_key)
-          primary_key.each_with_index do |key, i|
-           constraints[key] = primary_key_values[i]
-          end
-        end
-
-        constraints = _substitute_values(constraints).map { |attr, bind| attr.eq(bind) }
-
-        um = arel_table.where(
-          constraints.reduce(&:and)
-        ).compile_update(_substitute_values(values), primary_key)
-
-        connection.update(um, "#{self} Update")
-      end
-
-      def _delete_record(constraints) # :nodoc:
-        # CPK
-        if self.composite? && constraints[primary_key]
-          primary_key_values = constraints.delete(primary_key)
-          primary_key.each_with_index do |key, i|
-            constraints[key] = primary_key_values[i]
-          end
-        end
-
-        constraints = _substitute_values(constraints).map { |attr, bind| attr.eq(bind) }
-
-        dm = Arel::DeleteManager.new
-        dm.from(arel_table)
-        dm.wheres = constraints
-
-        connection.delete(dm, "#{self} Destroy")
-      end
-    end
-
-    def _create_record(attribute_names = self.attribute_names)
-      attribute_names = attributes_for_create(attribute_names)
-
-      new_id = self.class._insert_record(
-          attributes_with_values(attribute_names)
-      )
-
-      # CPK
-      if self.composite?
-        self.id = self.id.zip(Array(new_id)).map {|id1, id2| id2.nil? ? id1 : id2}
-      else
-        self.id ||= new_id if self.class.primary_key
-      end
-
-      @new_record = false
-
-      yield(self) if block_given?
-
-      id
-    end
-  end
-end
+module ActiveRecord
+  module Persistence
+    module ClassMethods
+      def delete(id_or_array)
+        # CPK
+        if self.composite?
+          id_or_array = if id_or_array.is_a?(CompositePrimaryKeys::CompositeKeys)
+                          [id_or_array]
+                        else
+                          Array(id_or_array)
+                        end
+
+          # Delete should return the number of deleted records
+          id_or_array.map do |id|
+            # Is the passed in id actually a record?
+            id = id.kind_of?(::ActiveRecord::Base) ? id.id : id
+            delete_by(cpk_id_predicate(self.arel_table, self.primary_key, id))
+          end.sum
+        else
+          delete_by(primary_key => id_or_array)
+        end
+      end
+
+      def _update_record(values, constraints) # :nodoc:
+        # CPK
+        if self.composite? && constraints[primary_key]
+          primary_key_values = constraints.delete(primary_key)
+          primary_key.each_with_index do |key, i|
+           constraints[key] = primary_key_values[i]
+          end
+        end
+
+        constraints = _substitute_values(constraints).map { |attr, bind| attr.eq(bind) }
+
+        um = arel_table.where(
+          constraints.reduce(&:and)
+        ).compile_update(_substitute_values(values), primary_key)
+
+        connection.update(um, "#{self} Update")
+      end
+
+      def _delete_record(constraints) # :nodoc:
+        # CPK
+        if self.composite? && constraints[primary_key]
+          primary_key_values = constraints.delete(primary_key)
+          primary_key.each_with_index do |key, i|
+            constraints[key] = primary_key_values[i]
+          end
+        end
+
+        constraints = _substitute_values(constraints).map { |attr, bind| attr.eq(bind) }
+
+        dm = Arel::DeleteManager.new
+        dm.from(arel_table)
+        dm.wheres = constraints
+
+        connection.delete(dm, "#{self} Destroy")
+      end
+    end
+
+    def _create_record(attribute_names = self.attribute_names)
+      attribute_names = attributes_for_create(attribute_names)
+
+      new_id = self.class._insert_record(
+          attributes_with_values(attribute_names)
+      )
+
+      # CPK
+      if self.composite?
+        self.id = self.id.zip(Array(new_id)).map {|id1, id2| id2.nil? ? id1 : id2}
+      else
+        self.id ||= new_id if self.class.primary_key
+      end
+
+      @new_record = false
+
+      yield(self) if block_given?
+
+      id
+    end
+  end
+end

data/lib/composite_primary_keys/reflection.rb

@@ -6,8 +6,8 @@ module ActiveRecord
         scope_chain_items = join_scopes(table, predicate_builder)
         klass_scope       = klass_join_scope(table, predicate_builder)
 
-        key         = join_keys.key
-        foreign_key = join_keys.foreign_key
+        key         = join_primary_key
+        foreign_key = join_foreign_key
 
         # CPK
         #klass_scope.where!(table[key].eq(foreign_table[foreign_key]))
@@ -25,5 +25,67 @@ module ActiveRecord
         scope_chain_items.inject(klass_scope, &:merge!)
       end
     end
+
+    class AssociationReflection < MacroReflection
+      def foreign_key
+        # CPK
+        # @foreign_key ||= -(options[:foreign_key]&.to_s || derive_foreign_key)
+        @foreign_key ||= extract_keys(options[:foreign_key]) || derive_foreign_key
+      end
+
+      def association_foreign_key
+        # CPK
+        # @association_foreign_key ||= -(options[:association_foreign_key]&.to_s || class_name.foreign_key)
+        @association_foreign_key ||= extract_keys(options[:association_foreign_key]) || class_name.foreign_key
+      end
+
+      def active_record_primary_key
+        # CPK (Rails freezes the string returned in the expression that calculates PK here. But Rails uses the `-` method which is not available on Array for CPK, so we calculate it in one line and freeze it on the next)
+        # @active_record_primary_key ||= -(options[:primary_key]&.to_s || primary_key(active_record))
+        @active_record_primary_key ||= begin
+          pk = options[:primary_key] || primary_key(active_record)
+          pk.freeze
+        end
+      end
+
+      private
+
+      def extract_keys(keys)
+        case keys
+          when Array
+            keys.map { |k| k.to_s }
+          when NilClass
+            nil
+          else
+            keys.to_s
+        end
+      end
+    end
+
+    class BelongsToReflection < AssociationReflection
+      def association_primary_key(klass = nil)
+        if primary_key = options[:primary_key]
+          # CPK
+          # @association_primary_key ||= -primary_key.to_s
+          @association_primary_key ||= primary_key.freeze
+        else
+          primary_key(klass || self.klass)
+        end
+      end
+    end
+
+    class ThroughReflection < AbstractReflection #:nodoc:
+      def association_primary_key(klass = nil)
+        # Get the "actual" source reflection if the immediate source reflection has a
+        # source reflection itself
+        if primary_key = actual_source_reflection.options[:primary_key]
+          # CPK
+          # @association_primary_key ||= -primary_key.to_s
+          @association_primary_key ||= primary_key.freeze
+        else
+          primary_key(klass || self.klass)
+        end
+      end
+    end
   end
 end

data/lib/composite_primary_keys/relation/batches.rb

@@ -1,12 +1,16 @@
 module CompositePrimaryKeys
   module ActiveRecord
     module Batches
-      def in_batches(of: 1000, start: nil, finish: nil, load: false, error_on_ignore: nil)
+      def in_batches(of: 1000, start: nil, finish: nil, load: false, error_on_ignore: nil, order: :asc)
         relation = self
         unless block_given?
           return ::ActiveRecord::Batches::BatchEnumerator.new(of: of, start: start, finish: finish, relation: self)
         end
 
+        unless [:asc, :desc].include?(order)
+          raise ArgumentError, ":order must be :asc or :desc, got #{order.inspect}"
+        end
+
         if arel.orders.present?
           act_on_ignored_order(error_on_ignore)
         end
@@ -17,8 +21,8 @@ module CompositePrimaryKeys
           batch_limit = remaining if remaining < batch_limit
         end
 
-        relation = relation.reorder(batch_order).limit(batch_limit)
-        relation = apply_limits(relation, start, finish)
+        relation = relation.reorder(batch_order(order)).limit(batch_limit)
+        relation = apply_limits(relation, start, finish, order)
         relation.skip_query_cache! # Retaining the results in the query cache would undermine the point of batching
         batch_relation = relation
 
@@ -61,7 +65,9 @@ module CompositePrimaryKeys
           end
 
           # CPK
-          # batch_relation = relation.where(arel_attribute(primary_key).gt(primary_key_offset))
+          #batch_relation = relation.where(
+          #  predicate_builder[primary_key, primary_key_offset, order == :desc ? :lt : :gt]
+          #)
           batch_relation = if composite?
             # CPK
             # Lexicographically select records
@@ -81,7 +87,9 @@ module CompositePrimaryKeys
             end.reduce(:or)
             relation.where(query)
           else
-            relation.where(arel_attribute(primary_key).gt(primary_key_offset))
+            batch_relation = relation.where(
+              predicate_builder[primary_key, primary_key_offset, order == :desc ? :lt : :gt]
+            )
           end
         end
       end
@@ -95,9 +103,9 @@ module CompositePrimaryKeys
         ary.length.times.reduce([]) { |results, i| results << ary[0..i] }
       end
 
-      def batch_order
+      def batch_order(order)
         self.primary_key.map do |key|
-          arel_attribute(key).asc
+          table[key].public_send(order)
         end
       end
     end

data/lib/composite_primary_keys/relation/calculations.rb

@@ -1,81 +1,104 @@
-module CompositePrimaryKeys
-  module ActiveRecord
-    module Calculations
-      def aggregate_column(column_name)
-        # CPK
-        if column_name.kind_of?(Array)
-          column_name.map do |column|
-            @klass.arel_attribute(column_name)
-          end
-        elsif @klass.has_attribute?(column_name) || @klass.attribute_alias?(column_name)
-          @klass.arel_attribute(column_name)
-        else
-          Arel.sql(column_name == :all ? "*" : column_name.to_s)
-        end
-      end
-
-      def execute_simple_calculation(operation, column_name, distinct) #:nodoc:
-        column_alias = column_name
-
-        # CPK
-        # if operation == "count" && (column_name == :all && distinct || has_limit_or_offset?)
-        #   # Shortcut when limit is zero.
-        #   return 0 if limit_value == 0
-        #
-        #   query_builder = build_count_subquery(spawn, column_name, distinct)
-        if operation == "count"
-          relation = unscope(:order)
-          query_builder = build_count_subquery(spawn, column_name, distinct)
-        else
-          # PostgreSQL doesn't like ORDER BY when there are no GROUP BY
-          relation = unscope(:order).distinct!(false)
-
-          column = aggregate_column(column_name)
-
-          select_value = operation_over_aggregate_column(column, operation, distinct)
-          if operation == "sum" && distinct
-            select_value.distinct = true
-          end
-
-          column_alias = select_value.alias
-          column_alias ||= @klass.connection.column_name_for_operation(operation, select_value)
-          relation.select_values = [select_value]
-
-          query_builder = relation.arel
-        end
-
-        result = skip_query_cache_if_necessary { @klass.connection.select_all(query_builder, nil) }
-        row    = result.first
-        value  = row && row.values.first
-        type   = result.column_types.fetch(column_alias) do
-          type_for(column_name)
-        end
-
-        type_cast_calculated_value(value, type, operation)
-      end
-
-      def build_count_subquery(relation, column_name, distinct)
-        if column_name == :all
-          relation.select_values = [ Arel.sql(::ActiveRecord::FinderMethods::ONE_AS_ONE) ] unless distinct
-          if relation.select_values.first.is_a?(Array)
-            relation.select_values = relation.select_values.first.map do |column|
-              Arel::Attribute.new(@klass.unscoped.table, column)
-            end
-          end
-        elsif column_name.is_a?(Array)
-          relation.select_values = column_name.map do |column|
-            Arel::Attribute.new(@klass.unscoped.table, column)
-          end
-        else
-          column_alias = Arel.sql("count_column")
-          relation.select_values = [ aggregate_column(column_name).as(column_alias) ]
-        end
-
-        subquery = relation.arel.as(Arel.sql("subquery_for_count"))
-        select_value = operation_over_aggregate_column(column_alias || Arel.star, "count", false)
-
-        Arel::SelectManager.new(subquery).project(select_value)
-      end
-    end
-  end
-end
+module CompositePrimaryKeys
+  module ActiveRecord
+    module Calculations
+      def aggregate_column(column_name)
+        # CPK
+        if column_name.kind_of?(Array)
+          # Note: Test don't seem to run this code?
+          column_name.map do |column|
+            @klass.arel_table[column]
+          end
+        elsif @klass.has_attribute?(column_name) || @klass.attribute_alias?(column_name)
+          @klass.arel_table[column_name]
+        else
+          Arel.sql(column_name == :all ? "*" : column_name.to_s)
+        end
+      end
+
+      def execute_simple_calculation(operation, column_name, distinct) #:nodoc:
+        column_alias = column_name
+
+        # CPK
+        # if operation == "count" && (column_name == :all && distinct || has_limit_or_offset?)
+        #   # Shortcut when limit is zero.
+        #   return 0 if limit_value == 0
+        #
+        #   query_builder = build_count_subquery(spawn, column_name, distinct)
+        if operation == "count"
+          relation = unscope(:order)
+          query_builder = build_count_subquery(spawn, column_name, distinct)
+        else
+          # PostgreSQL doesn't like ORDER BY when there are no GROUP BY
+          relation = unscope(:order).distinct!(false)
+
+          column = aggregate_column(column_name)
+          select_value = operation_over_aggregate_column(column, operation, distinct)
+          select_value.distinct = true if operation == "sum" && distinct
+
+          relation.select_values = [select_value]
+
+          query_builder = relation.arel
+        end
+
+        result = skip_query_cache_if_necessary { @klass.connection.select_all(query_builder) }
+
+        type_cast_calculated_value(result.cast_values.first, operation) do |value|
+          type = column.try(:type_caster) ||
+            # CPK
+            # lookup_cast_type_from_join_dependencies(column_name.to_s) || Type.default_value
+            lookup_cast_type_from_join_dependencies(column_name.to_s) || ::ActiveRecord::Type.default_value
+          type.deserialize(value)
+        end
+      end
+
+      def build_count_subquery(relation, column_name, distinct)
+        if column_name == :all
+          column_alias = Arel.star
+          # CPK
+          # relation.select_values = [ Arel.sql(FinderMethods::ONE_AS_ONE) ] unless distinct
+          relation.select_values = [ Arel.sql(::ActiveRecord::FinderMethods::ONE_AS_ONE) ] unless distinct
+        elsif column_name.is_a?(Array)
+          column_alias = Arel.star
+          relation.select_values = column_name.map do |column|
+            Arel::Attribute.new(@klass.unscoped.table, column)
+          end
+        else
+          column_alias = Arel.sql("count_column")
+          relation.select_values = [ aggregate_column(column_name).as(column_alias) ]
+        end
+
+        subquery_alias = Arel.sql("subquery_for_count")
+        select_value = operation_over_aggregate_column(column_alias, "count", false)
+
+        relation.build_subquery(subquery_alias, select_value)
+      end
+
+      def calculate(operation, column_name)
+        if has_include?(column_name)
+          relation = apply_join_dependency
+
+          if operation.to_s.downcase == "count"
+            unless distinct_value || distinct_select?(column_name || select_for_count)
+              relation.distinct!
+              # CPK
+              # relation.select_values = [ klass.primary_key || table[Arel.star] ]
+              if klass.primary_key.present? && klass.primary_key.is_a?(Array)
+                relation.select_values = klass.primary_key.map do |k|
+                  "#{connection.quote_table_name(klass.table_name)}.#{connection.quote_column_name(k)}"
+                end
+              else
+                relation.select_values = [ klass.primary_key || table[Arel.star] ]
+              end
+            end
+            # PostgreSQL: ORDER BY expressions must appear in SELECT list when using DISTINCT
+            relation.order_values = [] if group_values.empty?
+          end
+
+          relation.calculate(operation, column_name)
+        else
+          perform_calculation(operation, column_name)
+        end
+      end
+    end
+  end
+end

data/lib/composite_primary_keys/relation/finder_methods.rb

@@ -26,12 +26,12 @@ module CompositePrimaryKeys
       def limited_ids_for(relation)
         # CPK
         # values = @klass.connection.columns_for_distinct(
-        #     connection.column_name_from_arel_node(arel_attribute(primary_key)),
+        #     connection.column_name_from_arel_node(table[primary_key]),
         #     relation.order_values
         # )
 
         columns = @klass.primary_keys.map do |key|
-          connection.visitor.compile(arel_attribute(key))
+          connection.visitor.compile(table[key])
         end
         values = @klass.connection.columns_for_distinct(columns, relation.order_values)
 
@@ -110,12 +110,12 @@ module CompositePrimaryKeys
       #
       #   result = limit(limit || 1)
       #   # CPK
-      #   # result.order!(arel_attribute(primary_key)) if order_values.empty? && primary_key
+      #   # result.order!(table[primary_key]) if order_values.empty? && primary_key
       #   if order_values.empty? && primary_key
       #     if composite?
-      #       result.order!(primary_keys.map { |pk| arel_attribute(pk).asc })
+      #       result.order!(primary_keys.map { |pk| table[pk].asc })
       #     elsif
-      #       result.order!(arel_attribute(primary_key))
+      #       result.order!(table[primary_key])
       #     end
       #   end
       #
@@ -224,8 +224,8 @@ module CompositePrimaryKeys
       def ordered_relation
         if order_values.empty? && (implicit_order_column || primary_key)
           # CPK
-          # order(arel_attribute(implicit_order_column || primary_key).asc)
-          order(Array(implicit_order_column || primary_key).map {|key| arel_attribute(key).asc})
+          # order(table[implicit_order_column || primary_key].asc)
+          order(Array(implicit_order_column || primary_key).map {|key| table[key].asc})
         else
           self
         end

data/lib/composite_primary_keys/relation/predicate_builder/association_query_value.rb

@@ -3,16 +3,35 @@ module ActiveRecord
     class AssociationQueryValue
       def queries
         # CPK
-        if associated_table.association_join_foreign_key.is_a?(Array)
+        if associated_table.join_foreign_key.is_a?(Array)
           if ids.is_a?(ActiveRecord::Relation)
             ids.map do |id|
-              associated_table.association_join_foreign_key.zip(id.id).to_h
+              associated_table.join_foreign_key.zip(id.id).to_h
             end
           else
-            [associated_table.association_join_foreign_key.zip(ids).to_h]
+            [associated_table.join_foreign_key.zip(ids).to_h]
           end
         else
-          [associated_table.association_join_foreign_key.to_s => ids]
+          [associated_table.join_foreign_key => ids]
+        end
+      end
+
+      def ids
+        case value
+        when Relation
+          value.select_values.empty? ? value.select(primary_key) : value
+        when Array
+          value.map { |v| convert_to_id(v) }
+        else
+          # CPK
+          # convert_to_id(value)
+          if value.nil?
+            nil
+          elsif value.respond_to?(:composite?) && value.composite?
+            value.class.primary_keys.zip(value.id)
+          else
+            convert_to_id(value)
+          end
         end
       end
     end

data/lib/composite_primary_keys/relation/query_methods.rb

@@ -4,12 +4,12 @@ module CompositePrimaryKeys
       def reverse_sql_order(order_query)
         if order_query.empty?
           # CPK
-          # return [arel_attribute(primary_key).desc] if primary_key
+          # return [table[primary_key].desc] if primary_key
 
           if primary_key
             # break apart CPKs
             return primary_key.map do |key|
-              arel_attribute(key).desc
+              table[key].desc
             end
           else
             raise IrreversibleOrderError,

data/lib/composite_primary_keys/relation/where_clause.rb

@@ -1,23 +1,18 @@
 module ActiveRecord
   class Relation
     class WhereClause
-      def to_h(table_name = nil)
-        equalities = equalities(predicates)
+      def to_h(table_name = nil, equality_only: false)
+        equalities = equalities(predicates, equality_only)
 
         # CPK Adds this line, because ours are coming in with AND->{EQUALITY, EQUALITY}
         equalities = predicates.grep(Arel::Nodes::And).map(&:children).flatten.grep(Arel::Nodes::Equality) if equalities.empty?
 
-        if table_name
-          equalities = equalities.select do |node|
-            node.left.relation.name == table_name
-          end
-        end
-
-        equalities.map { |node|
+        equalities.each_with_object({}) do |node, hash|
+          next if table_name&.!= node.left.relation.name
           name = node.left.name.to_s
           value = extract_node_value(node.right)
-          [name, value]
-        }.to_h
+          hash[name] = value
+        end
       end
     end
   end