composite_primary_keys 13.0.7 → 14.0.1

data/lib/composite_primary_keys/persistence.rb

@@ -1,83 +1,96 @@
-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
-      @previously_new_record = true
-
-      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 = constraints.map { |name, value| predicate_builder[name, value] }
+
+        default_constraint = build_default_constraint
+        constraints << default_constraint if default_constraint
+
+        if current_scope = self.global_current_scope
+          constraints << current_scope.where_clause.ast
+        end
+
+        um = Arel::UpdateManager.new(arel_table)
+        um.set(values.transform_keys { |name| arel_table[name] })
+        um.wheres = constraints
+
+        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 = constraints.map { |name, value| predicate_builder[name, value] }
+
+        default_constraint = build_default_constraint
+        constraints << default_constraint if default_constraint
+
+        if current_scope = self.global_current_scope
+          constraints << current_scope.where_clause.ast
+        end
+
+        dm = Arel::DeleteManager.new(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
+      @previously_new_record = true
+
+      yield(self) if block_given?
+
+      id
+    end
+  end
+end

data/lib/composite_primary_keys/relation/calculations.rb

@@ -1,104 +1,110 @@
-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
+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) }
+
+        if operation != "count"
+          type = column.try(:type_caster) ||
+            lookup_cast_type_from_join_dependencies(column_name.to_s) || ::ActiveRecord::Type.default_value
+          type = type.subtype if ::ActiveRecord::Enum::EnumType === type
+        end
+
+        type_cast_calculated_value(result.cast_values.first, operation, type) 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.rb

@@ -29,7 +29,7 @@ module ActiveRecord
       stmt.key = table[primary_key]
 
       # CPK
-      if @klass.composite?
+      if @klass.composite? && @klass.connection.visitor.compile(stmt.ast) =~ /['"]#{primary_key.to_s}['"]/
         stmt = Arel::UpdateManager.new
         stmt.table(arel_table)
         cpk_subquery(stmt)
@@ -74,7 +74,7 @@ module ActiveRecord
       stmt.key = table[primary_key]
 
       # CPK
-      if @klass.composite?
+      if @klass.composite? && @klass.connection.visitor.compile(stmt.ast) =~ /['"]#{primary_key.to_s}['"]/
         stmt = Arel::DeleteManager.new
         stmt.from(arel_table)
         cpk_subquery(stmt)

data/lib/composite_primary_keys/validations/uniqueness.rb

@@ -1,32 +1,32 @@
-module ActiveRecord
-  module Validations
-    class UniquenessValidator
-      def validate_each(record, attribute, value)
-        finder_class = find_finder_class_for(record)
-        value = map_enum_attribute(finder_class, attribute, value)
-
-        relation = build_relation(finder_class, attribute, value)
-        if record.persisted?
-          # CPK
-          if finder_class.primary_key.is_a?(Array)
-            predicate = finder_class.cpk_id_predicate(finder_class.arel_table, finder_class.primary_key, record.id_in_database || record.id)
-            relation = relation.where.not(predicate)
-          elsif finder_class.primary_key
-            relation = relation.where.not(finder_class.primary_key => record.id_in_database)
-          else
-            raise UnknownPrimaryKey.new(finder_class, "Can not validate uniqueness for persisted record without primary key.")
-          end
-        end
-        relation = scope_relation(record, relation)
-        relation = relation.merge(options[:conditions]) if options[:conditions]
-
-        if relation.exists?
-          error_options = options.except(:case_sensitive, :scope, :conditions)
-          error_options[:value] = value
-
-          record.errors.add(attribute, :taken, **error_options)
-        end
-      end
-    end
-  end
+module ActiveRecord
+  module Validations
+    class UniquenessValidator
+      def validate_each(record, attribute, value)
+        finder_class = find_finder_class_for(record)
+        value = map_enum_attribute(finder_class, attribute, value)
+
+        relation = build_relation(finder_class, attribute, value)
+        if record.persisted?
+          # CPK
+          if finder_class.primary_key.is_a?(Array)
+            predicate = finder_class.cpk_id_predicate(finder_class.arel_table, finder_class.primary_key, record.id_in_database || record.id)
+            relation = relation.where.not(predicate)
+          elsif finder_class.primary_key
+            relation = relation.where.not(finder_class.primary_key => record.id_in_database)
+          else
+            raise UnknownPrimaryKey.new(finder_class, "Can not validate uniqueness for persisted record without primary key.")
+          end
+        end
+        relation = scope_relation(record, relation)
+        relation = relation.merge(options[:conditions]) if options[:conditions]
+
+        if relation.exists?
+          error_options = options.except(:case_sensitive, :scope, :conditions)
+          error_options[:value] = value
+
+          record.errors.add(attribute, :taken, **error_options)
+        end
+      end
+    end
+  end
 end

data/lib/composite_primary_keys/version.rb

@@ -1,8 +1,8 @@
-module CompositePrimaryKeys
-  module VERSION
-    MAJOR = 13
-    MINOR = 0
-    TINY  = 7
-    STRING = [MAJOR, MINOR, TINY].join('.')
-  end
-end
+module CompositePrimaryKeys
+  module VERSION
+    MAJOR = 14
+    MINOR = 0
+    TINY  = 1
+    STRING = [MAJOR, MINOR, TINY].join('.')
+  end
+end