composite_primary_keys 12.0.9 → 13.0.0

data/lib/composite_primary_keys/core.rb

@@ -1,49 +1,49 @@
-module ActiveRecord
-  module Core
-    def initialize_dup(other) # :nodoc:
-      @attributes = @attributes.deep_dup
-      # CPK
-      #@attributes.reset(@primary_key)
-      Array(self.class.primary_key).each {|key| @attributes.reset(key)}
-
-      _run_initialize_callbacks
-
-      @new_record               = true
-      @destroyed                = false
-      @_start_transaction_state = nil
-      @transaction_state        = nil
-
-      super
-    end
-
-    module ClassMethods
-      def find(*ids) # :nodoc:
-        # We don't have cache keys for this stuff yet
-        return super unless ids.length == 1
-        return super if block_given? ||
-            primary_key.nil? ||
-            scope_attributes? ||
-            columns_hash.key?(inheritance_column) && !base_class?
-
-        # CPK
-        return super if self.composite?
-
-        id = ids.first
-
-        return super if StatementCache.unsupported_value?(id)
-
-        key = primary_key
-
-        statement = cached_find_by_statement(key) { |params|
-          where(key => params.bind).limit(1)
-        }
-
-        record = statement.execute([id], connection)&.first
-        unless record
-          raise ::ActiveRecord::RecordNotFound.new("Couldn't find #{name} with '#{key}'=#{id}", name, key, id)
-        end
-        record
-      end
-    end
-  end
+module ActiveRecord
+  module Core
+    def initialize_dup(other) # :nodoc:
+      @attributes = @attributes.deep_dup
+      # CPK
+      #@attributes.reset(@primary_key)
+      Array(self.class.primary_key).each {|key| @attributes.reset(key)}
+
+      _run_initialize_callbacks
+
+      @new_record               = true
+      @destroyed                = false
+      @_start_transaction_state = nil
+      @transaction_state        = nil
+
+      super
+    end
+
+    module ClassMethods
+      def find(*ids) # :nodoc:
+        # We don't have cache keys for this stuff yet
+        return super unless ids.length == 1
+        return super if block_given? ||
+            primary_key.nil? ||
+            scope_attributes? ||
+            columns_hash.key?(inheritance_column) && !base_class?
+
+        # CPK
+        return super if self.composite?
+
+        id = ids.first
+
+        return super if StatementCache.unsupported_value?(id)
+
+        key = primary_key
+
+        statement = cached_find_by_statement(key) { |params|
+          where(key => params.bind).limit(1)
+        }
+
+        record = statement.execute([id], connection)&.first
+        unless record
+          raise ::ActiveRecord::RecordNotFound.new("Couldn't find #{name} with '#{key}'=#{id}", name, key, id)
+        end
+        record
+      end
+    end
+  end
 end

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,81 +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
-
-          id_or_array.each 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
-        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

@@ -1,29 +1,91 @@
-module ActiveRecord
-  module Reflection
-    class AbstractReflection
-      def join_scope(table, foreign_table, foreign_klass)
-        predicate_builder = predicate_builder(table)
-        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
-
-        # CPK
-        #klass_scope.where!(table[key].eq(foreign_table[foreign_key]))
-        constraint = cpk_join_predicate(table, key, foreign_table, foreign_key)
-        klass_scope.where!(constraint)
-
-        if type
-          klass_scope.where!(type => foreign_klass.polymorphic_name)
-        end
-
-        if klass.finder_needs_type_condition?
-          klass_scope.where!(klass.send(:type_condition, table))
-        end
-
-        scope_chain_items.inject(klass_scope, &:merge!)
-      end
-    end
-  end
-end
+module ActiveRecord
+  module Reflection
+    class AbstractReflection
+      def join_scope(table, foreign_table, foreign_klass)
+        predicate_builder = predicate_builder(table)
+        scope_chain_items = join_scopes(table, predicate_builder)
+        klass_scope       = klass_join_scope(table, predicate_builder)
+
+        key         = join_primary_key
+        foreign_key = join_foreign_key
+
+        # CPK
+        #klass_scope.where!(table[key].eq(foreign_table[foreign_key]))
+        constraint = cpk_join_predicate(table, key, foreign_table, foreign_key)
+        klass_scope.where!(constraint)
+
+        if type
+          klass_scope.where!(type => foreign_klass.polymorphic_name)
+        end
+
+        if klass.finder_needs_type_condition?
+          klass_scope.where!(klass.send(:type_condition, table))
+        end
+
+        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.rb

@@ -1,193 +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
-      # CPK
-      if @klass.composite?
-        stmt.table(arel_table)
-        cpk_subquery(stmt)
-      else
-        stmt.table(arel.join_sources.empty? ? table : arel.source)
-        stmt.key = arel_attribute(primary_key)
-        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 = arel_attribute(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
-
-      if @klass.composite?
-        stmt.from(arel_table)
-        cpk_subquery(stmt)
-      else
-        stmt.from(arel.join_sources.empty? ? table : arel.source)
-        stmt.key = arel_attribute(primary_key)
-        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|
-        arel_attribute(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|
-        arel_attribute(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.to_sql =~ /['"]#{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? && stmt.to_sql =~ /['"]#{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