composite_primary_keys 11.0.0.rc2 → 11.0.0

data/lib/composite_primary_keys/persistence.rb

@@ -1,112 +1,120 @@
-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
-
-          id_or_array.each do |id|
-            # Is the passed in id actually a record?
-            id = id.kind_of?(::ActiveRecord::Base) ? id.id : id
-            where(cpk_id_predicate(self.arel_table, self.primary_key, id)).delete_all
-          end
-        else
-          where(primary_key => id_or_array).delete_all
-        end
-      end
-
-      def _update_record(values, id, id_was) # :nodoc:
-        # # CPK
-        # if self.composite?
-        #   relation = @klass.unscoped.where(cpk_id_predicate(@klass.arel_table, @klass.primary_key, id_was || id))
-        # else
-        #   relation = scope.where(@klass.primary_key => (id_was || id))
-        # end
-
-        # CPK
-        # bind = predicate_builder.build_bind_attribute(primary_key, id_was || id)
-        # um = arel_table.where(
-        #     arel_attribute(primary_key).eq(bind)
-        # ).compile_update(_substitute_values(values), primary_key)
-
-        # CPK
-        if self.composite?
-          predicate = cpk_id_predicate(arel_table, primary_key, id_was || id)
-          um = arel_table.where(predicate).compile_update(_substitute_values(values), primary_key)
-        else
-          bind = predicate_builder.build_bind_attribute(primary_key, id_was || id)
-          um = arel_table.where(
-              arel_attribute(primary_key).eq(bind)
-          ).compile_update(_substitute_values(values), primary_key)
-        end
-
-        connection.update(um, "#{self} Update")
-      end
-    end
-
-    def _relation_for_itself
-      # CPK
-      if self.composite?
-        relation = self.class.unscoped
-
-        Array(self.class.primary_key).each do |key|
-          column     = self.class.arel_table[key]
-          value      = self[key]
-          relation = relation.where(column.eq(value))
-        end
-
-        relation
-      else
-        self.class.unscoped.where(self.class.primary_key => id)
-      end
-    end
-
-    def touch(*names, time: nil)
-      raise ActiveRecordError, "cannot touch on a new record object" unless persisted?
-
-      time ||= current_time_from_proper_timezone
-      attributes = timestamp_attributes_for_update_in_model
-      attributes.concat(names)
-
-      unless attributes.empty?
-        changes = {}
-
-        attributes.each do |column|
-          column = column.to_s
-          changes[column] = write_attribute(column, time)
-        end
-
-        clear_attribute_changes(changes.keys)
-        primary_key = self.class.primary_key
-        scope = self.class.unscoped.where(primary_key => _read_attribute(primary_key))
-
-        if locking_enabled?
-          locking_column = self.class.locking_column
-          scope = scope.where(locking_column => _read_attribute(locking_column))
-          changes[locking_column] = increment_lock
-        end
-
-        # CPK
-        if composite?
-          primary_key_predicate = self.class.unscoped.cpk_id_predicate(self.class.arel_table, Array(primary_key), Array(id))
-          scope = self.class.unscoped.where(primary_key_predicate)
-        end
-
-        result = scope.update_all(changes) == 1
-
-        if !result && locking_enabled?
-          raise ActiveRecord::StaleObjectError.new(self, "touch")
-        end
-
-        result
-      else
-        true
-      end
-    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
+
+          id_or_array.each do |id|
+            # Is the passed in id actually a record?
+            id = id.kind_of?(::ActiveRecord::Base) ? id.id : id
+            where(cpk_id_predicate(self.arel_table, self.primary_key, id)).delete_all
+          end
+        else
+          where(primary_key => id_or_array).delete_all
+        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 _relation_for_itself
+      # CPK
+      if self.composite?
+        relation = self.class.unscoped
+
+        Array(self.class.primary_key).each do |key|
+          column     = self.class.arel_table[key]
+          value      = self[key]
+          relation = relation.where(column.eq(value))
+        end
+
+        relation
+      else
+        self.class.unscoped.where(self.class.primary_key => id)
+      end
+    end
+
+    def touch(*names, time: nil)
+      raise ActiveRecordError, "cannot touch on a new record object" unless persisted?
+
+      time ||= current_time_from_proper_timezone
+      attributes = timestamp_attributes_for_update_in_model
+      attributes.concat(names)
+
+      unless attributes.empty?
+        changes = {}
+
+        attributes.each do |column|
+          column = column.to_s
+          changes[column] = write_attribute(column, time)
+        end
+
+        clear_attribute_changes(changes.keys)
+        primary_key = self.class.primary_key
+        scope = self.class.unscoped.where(primary_key => _read_attribute(primary_key))
+
+        if locking_enabled?
+          locking_column = self.class.locking_column
+          scope = scope.where(locking_column => _read_attribute(locking_column))
+          changes[locking_column] = increment_lock
+        end
+
+        # CPK
+        if composite?
+          primary_key_predicate = self.class.unscoped.cpk_id_predicate(self.class.arel_table, Array(primary_key), Array(id))
+          scope = self.class.unscoped.where(primary_key_predicate)
+        end
+
+        result = scope.update_all(changes) == 1
+
+        if !result && locking_enabled?
+          raise ActiveRecord::StaleObjectError.new(self, "touch")
+        end
+
+        result
+      else
+        true
+      end
+    end
+  end
+end

data/lib/composite_primary_keys/reflection.rb

@@ -1,20 +1,20 @@
-module ActiveRecord
-  module Reflection
-    class AbstractReflection
-      def build_join_constraint(table, foreign_table)
-        key         = join_keys.key
-        foreign_key = join_keys.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?
-          table.create_and([constraint, klass.send(:type_condition, table)])
-        else
-          constraint
-        end
-      end
-    end
-  end
-end
+module ActiveRecord
+  module Reflection
+    class AbstractReflection
+      def build_join_constraint(table, foreign_table)
+        key         = join_keys.key
+        foreign_key = join_keys.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?
+          table.create_and([constraint, klass.send(:type_condition, table)])
+        else
+          constraint
+        end
+      end
+    end
+  end
+end

data/lib/composite_primary_keys/relation.rb

@@ -1,88 +1,88 @@
-module ActiveRecord
-  class Relation
-    alias :initialize_without_cpk :initialize
-    def initialize(klass, table: klass.arel_table, predicate_builder: klass.predicate_builder, values: {})
-      initialize_without_cpk(klass, table: table, predicate_builder: predicate_builder, values: values)
-      add_cpk_support if klass && klass.composite?
-    end
-
-    alias :initialize_copy_without_cpk :initialize_copy
-    def initialize_copy(other)
-      initialize_copy_without_cpk(other)
-      add_cpk_support if klass.composite?
-    end
-
-    def add_cpk_support
-      extend CompositePrimaryKeys::CompositeRelation
-    end
-
-    def update_all(updates)
-      raise ArgumentError, "Empty list of attributes to change" if updates.blank?
-
-      if eager_loading?
-        relation = apply_join_dependency
-        return relation.update_all(updates)
-      end
-
-      stmt = Arel::UpdateManager.new
-
-      stmt.set Arel.sql(@klass.send(:sanitize_sql_for_assignment, updates))
-      stmt.table(table)
-
-      if has_join_values?
-        # CPK
-        #@klass.connection.join_to_update(stmt, arel, arel_attribute(primary_key))
-        if primary_key.kind_of?(Array)
-          attributes = primary_key.map do |key|
-            arel_attribute(key)
-          end
-          @klass.connection.join_to_update(stmt, arel, attributes.to_composite_keys)
-        else
-          @klass.connection.join_to_update(stmt, arel, arel_attribute(primary_key))
-        end
-      else
-        stmt.key = arel_attribute(primary_key)
-        stmt.take(arel.limit)
-        stmt.order(*arel.orders)
-        stmt.wheres = arel.constraints
-      end
-
-      @klass.connection.update stmt, "#{@klass} Update All"
-    end
-
-    def delete_all
-      invalid_methods = INVALID_METHODS_FOR_DELETE_ALL.select do |method|
-        value = get_value(method)
-        SINGLE_VALUE_METHODS.include?(method) ? value : value.any?
-      end
-      if invalid_methods.any?
-        raise ActiveRecordError.new("delete_all doesn't support #{invalid_methods.join(', ')}")
-      end
-
-      if eager_loading?
-        relation = apply_join_dependency
-        return relation.delete_all
-      end
-
-      stmt = Arel::DeleteManager.new
-      stmt.from(table)
-
-      # CPK
-      if has_join_values? && @klass.composite?
-        arel_attributes = primary_key.map do |key|
-          arel_attribute(key)
-        end.to_composite_keys
-        @klass.connection.join_to_delete(stmt, arel, arel_attributes)
-      elsif has_join_values? || has_limit_or_offset?
-        @klass.connection.join_to_delete(stmt, arel, arel_attribute(primary_key))
-      else
-        stmt.wheres = arel.constraints
-      end
-
-      affected = @klass.connection.delete(stmt, "#{@klass} Destroy")
-
-      reset
-      affected
-    end
-  end
-end
+module ActiveRecord
+  class Relation
+    alias :initialize_without_cpk :initialize
+    def initialize(klass, table: klass.arel_table, predicate_builder: klass.predicate_builder, values: {})
+      initialize_without_cpk(klass, table: table, predicate_builder: predicate_builder, values: values)
+      add_cpk_support if klass && klass.composite?
+    end
+
+    alias :initialize_copy_without_cpk :initialize_copy
+    def initialize_copy(other)
+      initialize_copy_without_cpk(other)
+      add_cpk_support if klass.composite?
+    end
+
+    def add_cpk_support
+      extend CompositePrimaryKeys::CompositeRelation
+    end
+
+    def update_all(updates)
+      raise ArgumentError, "Empty list of attributes to change" if updates.blank?
+
+      if eager_loading?
+        relation = apply_join_dependency
+        return relation.update_all(updates)
+      end
+
+      stmt = Arel::UpdateManager.new
+
+      stmt.set Arel.sql(@klass.send(:sanitize_sql_for_assignment, updates))
+      stmt.table(table)
+
+      if has_join_values?
+        # CPK
+        #@klass.connection.join_to_update(stmt, arel, arel_attribute(primary_key))
+        if primary_key.kind_of?(Array)
+          attributes = primary_key.map do |key|
+            arel_attribute(key)
+          end
+          @klass.connection.join_to_update(stmt, arel, attributes.to_composite_keys)
+        else
+          @klass.connection.join_to_update(stmt, arel, arel_attribute(primary_key))
+        end
+      else
+        stmt.key = arel_attribute(primary_key)
+        stmt.take(arel.limit)
+        stmt.order(*arel.orders)
+        stmt.wheres = arel.constraints
+      end
+
+      @klass.connection.update stmt, "#{@klass} Update All"
+    end
+
+    def delete_all
+      invalid_methods = INVALID_METHODS_FOR_DELETE_ALL.select do |method|
+        value = get_value(method)
+        SINGLE_VALUE_METHODS.include?(method) ? value : value.any?
+      end
+      if invalid_methods.any?
+        raise ActiveRecordError.new("delete_all doesn't support #{invalid_methods.join(', ')}")
+      end
+
+      if eager_loading?
+        relation = apply_join_dependency
+        return relation.delete_all
+      end
+
+      stmt = Arel::DeleteManager.new
+      stmt.from(table)
+
+      # CPK
+      if has_join_values? && @klass.composite?
+        arel_attributes = primary_key.map do |key|
+          arel_attribute(key)
+        end.to_composite_keys
+        @klass.connection.join_to_delete(stmt, arel, arel_attributes)
+      elsif has_join_values? || has_limit_or_offset?
+        @klass.connection.join_to_delete(stmt, arel, arel_attribute(primary_key))
+      else
+        stmt.wheres = arel.constraints
+      end
+
+      affected = @klass.connection.delete(stmt, "#{@klass} Destroy")
+
+      reset
+      affected
+    end
+  end
+end

data/lib/composite_primary_keys/relation/calculations.rb

@@ -1,79 +1,79 @@
-module CompositePrimaryKeys
-  module ActiveRecord
-    module Calculations
-      def aggregate_column(column_name)
-        # CPK
-        if column_name.kind_of?(Array)
-          column_name.map do |column|
-            Arel::Attribute.new(@klass.unscoped.table, column)
-          end
-        elsif @klass.column_names.include?(column_name.to_s)
-          Arel::Attribute.new(@klass.unscoped.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" && 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(relation, 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)
-        relation.select_values = [
-            if column_name == :all
-              distinct ? table[Arel.star] : Arel.sql(::ActiveRecord::FinderMethods::ONE_AS_ONE)
-            # CPK
-            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")
-              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)
+          column_name.map do |column|
+            Arel::Attribute.new(@klass.unscoped.table, column)
+          end
+        elsif @klass.column_names.include?(column_name.to_s)
+          Arel::Attribute.new(@klass.unscoped.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" && 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(relation, 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)
+        relation.select_values = [
+            if column_name == :all
+              distinct ? table[Arel.star] : Arel.sql(::ActiveRecord::FinderMethods::ONE_AS_ONE)
+            # CPK
+            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")
+              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