composite_primary_keys 14.0.9 → 14.0.10

data/lib/composite_primary_keys/relation.rb

@@ -1,199 +1,199 @@
-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::TrilogyAdapter) && connection.is_a?(ActiveRecord::ConnectionAdapters::TrilogyAdapter)
-        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::TrilogyAdapter) && connection.is_a?(ActiveRecord::ConnectionAdapters::TrilogyAdapter)
+        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,40 +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)
-        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
+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  = 9
+    TINY  = 10
     STRING = [MAJOR, MINOR, TINY].join('.')
   end
 end