composite_primary_keys 14.0.4 → 14.0.6

data/lib/composite_primary_keys/relation.rb

@@ -1,197 +1,197 @@
-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.table(arel.join_sources.empty? ? table : arel.source)
-      stmt.key = table[primary_key]
-
-      # CPK
-      if @klass.composite? && @klass.connection.visitor.compile(stmt.ast) =~ /['"]#{primary_key.to_s}['"]/
-        stmt = Arel::UpdateManager.new
-        stmt.table(arel_table)
-        cpk_subquery(stmt)
-      else
-        stmt.wheres = arel.constraints
-      end
-      stmt.take(arel.limit)
-      stmt.offset(arel.offset)
-      stmt.order(*arel.orders)
-
-      if updates.is_a?(Hash)
-        if klass.locking_enabled? &&
-            !updates.key?(klass.locking_column) &&
-            !updates.key?(klass.locking_column.to_sym)
-          attr = table[klass.locking_column]
-          updates[attr.name] = _increment_attribute(attr)
-        end
-        stmt.set _substitute_values(updates)
-      else
-        stmt.set Arel.sql(klass.sanitize_sql_for_assignment(updates, table.name))
-      end
-
-      @klass.connection.update stmt, "#{@klass} Update All"
-    end
-
-    def delete_all
-      invalid_methods = INVALID_METHODS_FOR_DELETE_ALL.select do |method|
-        value = @values[method]
-        method == :distinct ? 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(arel.join_sources.empty? ? table : arel.source)
-      stmt.key = table[primary_key]
-
-      # CPK
-      if @klass.composite? && @klass.connection.visitor.compile(stmt.ast) =~ /['"]#{primary_key.to_s}['"]/
-        stmt = Arel::DeleteManager.new
-        stmt.from(arel_table)
-        cpk_subquery(stmt)
-      else
-        stmt.wheres = arel.constraints
-      end
-
-      stmt.take(arel.limit)
-      stmt.offset(arel.offset)
-      stmt.order(*arel.orders)
-
-      affected = @klass.connection.delete(stmt, "#{@klass} Destroy")
-
-      reset
-      affected
-    end
-
-    # CPK
-    def cpk_subquery(stmt)
-      # For update and delete statements we need a way to specify which records should
-      # get updated. By default, Rails creates a nested IN subquery that uses the primary
-      # key. Postgresql, Sqlite, MariaDb and Oracle support IN subqueries with multiple
-      # columns but MySQL and SqlServer do not. Instead SQL server supports EXISTS queries
-      # and MySQL supports obfuscated IN queries. Thus we need to check the type of
-      # database adapter to decide how to proceed.
-      if defined?(ActiveRecord::ConnectionAdapters::Mysql2Adapter) && connection.is_a?(ActiveRecord::ConnectionAdapters::Mysql2Adapter)
-        cpk_mysql_subquery(stmt)
-      elsif defined?(ActiveRecord::ConnectionAdapters::SQLServerAdapter) && connection.is_a?(ActiveRecord::ConnectionAdapters::SQLServerAdapter)
-        cpk_exists_subquery(stmt)
-      else
-        cpk_in_subquery(stmt)
-      end
-    end
-
-    # Used by postgresql, sqlite, mariadb and oracle. Example query:
-    #
-    # UPDATE reference_codes
-    # SET ...
-    # WHERE (reference_codes.reference_type_id, reference_codes.reference_code) IN
-    #      (SELECT reference_codes.reference_type_id, reference_codes.reference_code
-    #       FROM reference_codes)
-    def cpk_in_subquery(stmt)
-      # Setup the subquery
-      subquery = arel.clone
-      subquery.projections = primary_keys.map do |key|
-        arel_table[key]
-      end
-
-      where_fields = primary_keys.map do |key|
-        arel_table[key]
-      end
-      where = Arel::Nodes::Grouping.new(where_fields).in(subquery)
-      stmt.wheres = [where]
-    end
-
-    # CPK. This is an alternative to IN subqueries. It is used by sqlserver.
-    # Example query:
-    #
-    # UPDATE reference_codes
-    # SET ...
-    # WHERE EXISTS
-    #  (SELECT 1
-    #  FROM reference_codes cpk_child
-    #  WHERE reference_codes.reference_type_id = cpk_child.reference_type_id AND
-    #        reference_codes.reference_code = cpk_child.reference_code)
-    def cpk_exists_subquery(stmt)
-      arel_attributes = primary_keys.map do |key|
-        table[key]
-      end.to_composite_keys
-
-      # Clone the query
-      subselect = arel.clone
-
-      # Alias the table - we assume just one table
-      aliased_table = subselect.froms.first
-      aliased_table.table_alias = "cpk_child"
-
-      # Project - really we could just set this to "1"
-      subselect.projections = arel_attributes
-
-      # Setup correlation to the outer query via where clauses
-      primary_keys.map do |key|
-        outer_attribute = arel_table[key]
-        inner_attribute = aliased_table[key]
-        where = outer_attribute.eq(inner_attribute)
-        subselect.where(where)
-      end
-      stmt.wheres = [Arel::Nodes::Exists.new(subselect)]
-    end
-
-    # CPK. This is the old way CPK created subqueries and is used by MySql.
-    # MySQL does not support referencing the same table that is being UPDATEd or
-    # DELETEd in a subquery so we obfuscate it. The ugly query looks like this:
-    #
-    # UPDATE `reference_codes`
-    # SET ...
-    # WHERE (reference_codes.reference_type_id, reference_codes.reference_code) IN
-    #  (SELECT reference_type_id,reference_code
-    #   FROM (SELECT DISTINCT `reference_codes`.`reference_type_id`, `reference_codes`.`reference_code`
-    #         FROM `reference_codes`) __active_record_temp)
-    def cpk_mysql_subquery(stmt)
-      arel_attributes = primary_keys.map do |key|
-        table[key]
-      end.to_composite_keys
-
-      subselect = arel.clone
-      subselect.projections = arel_attributes
-
-      # Materialize subquery by adding distinct
-      # to work with MySQL 5.7.6 which sets optimizer_switch='derived_merge=on'
-      subselect.distinct unless arel.limit || arel.offset || arel.orders.any?
-
-      key_name = arel_attributes.map(&:name).join(',')
-
-      manager = Arel::SelectManager.new(subselect.as("__active_record_temp")).project(Arel.sql(key_name))
-
-      stmt.wheres = [Arel::Nodes::In.new(arel_attributes, manager.ast)]
-    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.table(arel.join_sources.empty? ? table : arel.source)
+      stmt.key = table[primary_key]
+
+      # CPK
+      if @klass.composite?
+        stmt = Arel::UpdateManager.new
+        stmt.table(arel_table)
+        cpk_subquery(stmt)
+      else
+        stmt.wheres = arel.constraints
+      end
+      stmt.take(arel.limit)
+      stmt.offset(arel.offset)
+      stmt.order(*arel.orders)
+
+      if updates.is_a?(Hash)
+        if klass.locking_enabled? &&
+            !updates.key?(klass.locking_column) &&
+            !updates.key?(klass.locking_column.to_sym)
+          attr = table[klass.locking_column]
+          updates[attr.name] = _increment_attribute(attr)
+        end
+        stmt.set _substitute_values(updates)
+      else
+        stmt.set Arel.sql(klass.sanitize_sql_for_assignment(updates, table.name))
+      end
+
+      @klass.connection.update stmt, "#{@klass} Update All"
+    end
+
+    def delete_all
+      invalid_methods = INVALID_METHODS_FOR_DELETE_ALL.select do |method|
+        value = @values[method]
+        method == :distinct ? 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(arel.join_sources.empty? ? table : arel.source)
+      stmt.key = table[primary_key]
+
+      # CPK
+      if @klass.composite?
+        stmt = Arel::DeleteManager.new
+        stmt.from(arel_table)
+        cpk_subquery(stmt)
+      else
+        stmt.wheres = arel.constraints
+      end
+
+      stmt.take(arel.limit)
+      stmt.offset(arel.offset)
+      stmt.order(*arel.orders)
+
+      affected = @klass.connection.delete(stmt, "#{@klass} Destroy")
+
+      reset
+      affected
+    end
+
+    # CPK
+    def cpk_subquery(stmt)
+      # For update and delete statements we need a way to specify which records should
+      # get updated. By default, Rails creates a nested IN subquery that uses the primary
+      # key. Postgresql, Sqlite, MariaDb and Oracle support IN subqueries with multiple
+      # columns but MySQL and SqlServer do not. Instead SQL server supports EXISTS queries
+      # and MySQL supports obfuscated IN queries. Thus we need to check the type of
+      # database adapter to decide how to proceed.
+      if defined?(ActiveRecord::ConnectionAdapters::Mysql2Adapter) && connection.is_a?(ActiveRecord::ConnectionAdapters::Mysql2Adapter)
+        cpk_mysql_subquery(stmt)
+      elsif defined?(ActiveRecord::ConnectionAdapters::SQLServerAdapter) && connection.is_a?(ActiveRecord::ConnectionAdapters::SQLServerAdapter)
+        cpk_exists_subquery(stmt)
+      else
+        cpk_in_subquery(stmt)
+      end
+    end
+
+    # Used by postgresql, sqlite, mariadb and oracle. Example query:
+    #
+    # UPDATE reference_codes
+    # SET ...
+    # WHERE (reference_codes.reference_type_id, reference_codes.reference_code) IN
+    #      (SELECT reference_codes.reference_type_id, reference_codes.reference_code
+    #       FROM reference_codes)
+    def cpk_in_subquery(stmt)
+      # Setup the subquery
+      subquery = arel.clone
+      subquery.projections = primary_keys.map do |key|
+        arel_table[key]
+      end
+
+      where_fields = primary_keys.map do |key|
+        arel_table[key]
+      end
+      where = Arel::Nodes::Grouping.new(where_fields).in(subquery)
+      stmt.wheres = [where]
+    end
+
+    # CPK. This is an alternative to IN subqueries. It is used by sqlserver.
+    # Example query:
+    #
+    # UPDATE reference_codes
+    # SET ...
+    # WHERE EXISTS
+    #  (SELECT 1
+    #  FROM reference_codes cpk_child
+    #  WHERE reference_codes.reference_type_id = cpk_child.reference_type_id AND
+    #        reference_codes.reference_code = cpk_child.reference_code)
+    def cpk_exists_subquery(stmt)
+      arel_attributes = primary_keys.map do |key|
+        table[key]
+      end.to_composite_keys
+
+      # Clone the query
+      subselect = arel.clone
+
+      # Alias the table - we assume just one table
+      aliased_table = subselect.froms.first
+      aliased_table.table_alias = "cpk_child"
+
+      # Project - really we could just set this to "1"
+      subselect.projections = arel_attributes
+
+      # Setup correlation to the outer query via where clauses
+      primary_keys.map do |key|
+        outer_attribute = arel_table[key]
+        inner_attribute = aliased_table[key]
+        where = outer_attribute.eq(inner_attribute)
+        subselect.where(where)
+      end
+      stmt.wheres = [Arel::Nodes::Exists.new(subselect)]
+    end
+
+    # CPK. This is the old way CPK created subqueries and is used by MySql.
+    # MySQL does not support referencing the same table that is being UPDATEd or
+    # DELETEd in a subquery so we obfuscate it. The ugly query looks like this:
+    #
+    # UPDATE `reference_codes`
+    # SET ...
+    # WHERE (reference_codes.reference_type_id, reference_codes.reference_code) IN
+    #  (SELECT reference_type_id,reference_code
+    #   FROM (SELECT DISTINCT `reference_codes`.`reference_type_id`, `reference_codes`.`reference_code`
+    #         FROM `reference_codes`) __active_record_temp)
+    def cpk_mysql_subquery(stmt)
+      arel_attributes = primary_keys.map do |key|
+        table[key]
+      end.to_composite_keys
+
+      subselect = arel.clone
+      subselect.projections = arel_attributes
+
+      # Materialize subquery by adding distinct
+      # to work with MySQL 5.7.6 which sets optimizer_switch='derived_merge=on'
+      subselect.distinct unless arel.limit || arel.offset || arel.orders.any?
+
+      key_name = arel_attributes.map(&:name).join(',')
+
+      manager = Arel::SelectManager.new(subselect.as("__active_record_temp")).project(Arel.sql(key_name))
+
+      stmt.wheres = [Arel::Nodes::In.new(arel_attributes, manager.ast)]
+    end
+  end
+end

data/lib/composite_primary_keys/validations/uniqueness.rb

@@ -1,32 +1,40 @@
-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
+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)
+        if options[:conditions]
+          conditions = options[:conditions]
+
+          relation = if conditions.arity.zero?
+            relation.instance_exec(&conditions)
+          else
+            relation.instance_exec(record, &conditions)
+          end
+        end
+
+        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

@@ -2,7 +2,7 @@ module CompositePrimaryKeys
   module VERSION
     MAJOR = 14
     MINOR = 0
-    TINY  = 4
+    TINY  = 6
     STRING = [MAJOR, MINOR, TINY].join('.')
   end
 end

data/test/fixtures/room_assignment.rb

@@ -1,14 +1,18 @@
-class RoomAssignment < ActiveRecord::Base
-  self.primary_keys = :student_id, :dorm_id, :room_id
-  belongs_to :student
-  belongs_to :room, :foreign_key => [:dorm_id, :room_id], :primary_key => [:dorm_id, :room_id]
-  validates_uniqueness_of :student_id
-
-  before_destroy do |record|
-    puts record
-  end
-
-  after_destroy do |record|
-    puts record
-  end
-end
+class RoomAssignment < ActiveRecord::Base
+  self.primary_keys = :student_id, :dorm_id, :room_id
+  belongs_to :student
+  belongs_to :room, :foreign_key => [:dorm_id, :room_id], :primary_key => [:dorm_id, :room_id]
+  validates :student_id, uniqueness: {
+    conditions: ->(record) {
+      where(student_id: record.student_id) # enough just to exercise this code path
+    }
+  }
+
+  before_destroy do |record|
+    puts record
+  end
+
+  after_destroy do |record|
+    puts record
+  end
+end

data/test/test_associations.rb

@@ -367,7 +367,29 @@ class TestAssociations < ActiveSupport::TestCase
     assert_equal(false, associations.send('foreign_key_present?'))
   end
 
-  def test_ids_equals_for_non_CPK_case
+  def test_assignment_by_ids_as_arrays
+    room = Room.create dorm: dorms(:branner), room_id: 4
+    room.room_assignment_ids = [[3, 1, 2], [4, 1, 2]]
+    room.save!
+    assert_equal room.room_assignments.map(&:student_id), [3, 4]
+  end
+
+  def test_assignment_by_ids_as_arrays_that_contains_a_comma
+    room = Room.create dorm: dorms(:branner), room_id: 4
+    e = assert_raises ActiveRecord::RecordNotFound do
+      room.room_assignment_ids = [['5,,', '5,,', '5,,']]
+    end
+    assert_match /'student_id,dorm_id,room_id'=\[\[5, 5, 5\]\]/, e.message
+  end
+
+  def test_assignment_by_ids_as_strings
+    room = Room.create dorm: dorms(:branner), room_id: 4
+    room.room_assignment_ids = ['3,1,2', '4,1,2']
+    room.save!
+    assert_equal room.room_assignments.map(&:student_id), [3, 4]
+  end
+
+  def test_assignment_by_ids_for_non_CPK_case
     article = Article.new
     article.reading_ids = Reading.pluck(:id)
     assert_equal article.reading_ids, Reading.pluck(:id)

data/test/test_composite_arrays.rb

@@ -1,38 +1,44 @@
-require File.expand_path('../abstract_unit', __FILE__)
-
-class CompositeArraysTest < ActiveSupport::TestCase
-
-  def test_new_primary_keys
-    keys = CompositePrimaryKeys::CompositeKeys.new
-    assert_not_nil keys
-    assert_equal '', keys.to_s
-    assert_equal '', "#{keys}"
-  end
-
-  def test_initialize_primary_keys
-    keys = CompositePrimaryKeys::CompositeKeys.new([1,2,3])
-    assert_not_nil keys
-    assert_equal '1,2,3', keys.to_s
-    assert_equal '1,2,3', "#{keys}"
-  end
-
-  def test_to_composite_keys
-    keys = [1,2,3].to_composite_keys
-    assert_equal CompositePrimaryKeys::CompositeKeys, keys.class
-    assert_equal '1,2,3', keys.to_s
-  end
-
-  def test_parse
-    assert_equal ['1', '2'], CompositePrimaryKeys::CompositeKeys.parse('1,2')
-    assert_equal ['The USA', '^Washington, D.C.'],
-                 CompositePrimaryKeys::CompositeKeys.parse('The USA,^5EWashington^2C D.C.')
-    assert_equal ['The USA', '^Washington, D.C.'],
-                 CompositePrimaryKeys::CompositeKeys.parse(['The USA', '^Washington, D.C.'])
-  end
-
-  def test_to_s
-    assert_equal '1,2', CompositePrimaryKeys::CompositeKeys.new([1, 2]).to_s
-    assert_equal 'The USA,^5EWashington^2C D.C.',
-                 CompositePrimaryKeys::CompositeKeys.new(['The USA', '^Washington, D.C.']).to_s
-  end
-end
+require File.expand_path('../abstract_unit', __FILE__)
+
+class CompositeArraysTest < ActiveSupport::TestCase
+
+  def test_new_primary_keys
+    keys = CompositePrimaryKeys::CompositeKeys.new
+    assert_not_nil keys
+    assert_equal '', keys.to_s
+    assert_equal '', "#{keys}"
+  end
+
+  def test_initialize_primary_keys
+    keys = CompositePrimaryKeys::CompositeKeys.new([1,2,3])
+    assert_not_nil keys
+    assert_equal '1,2,3', keys.to_s
+    assert_equal '1,2,3', "#{keys}"
+  end
+
+  def test_to_composite_keys
+    keys = [1,2,3].to_composite_keys
+    assert_equal CompositePrimaryKeys::CompositeKeys, keys.class
+    assert_equal '1,2,3', keys.to_s
+  end
+
+  def test_parse
+    assert_equal ['1', '2'], CompositePrimaryKeys::CompositeKeys.parse('1,2')
+    assert_equal ['The USA', '^Washington, D.C.'],
+                 CompositePrimaryKeys::CompositeKeys.parse('The USA,^5EWashington^2C D.C.')
+    assert_equal ['The USA', '^Washington, D.C.'],
+                 CompositePrimaryKeys::CompositeKeys.parse(['The USA', '^Washington, D.C.'])
+  end
+
+  def test_to_s
+    assert_equal '1,2', CompositePrimaryKeys::CompositeKeys.new([1, 2]).to_s
+    assert_equal 'The USA,^5EWashington^2C D.C.',
+                 CompositePrimaryKeys::CompositeKeys.new(['The USA', '^Washington, D.C.']).to_s
+  end
+
+  def test_to_param
+    assert_equal '1,2', CompositePrimaryKeys::CompositeKeys.new([1, 2]).to_param
+    assert_equal 'The USA,^5EWashington^2C D.C.',
+                 CompositePrimaryKeys::CompositeKeys.new(['The USA', '^Washington, D.C.']).to_param
+  end
+end