composite_primary_keys 12.0.9 → 13.0.2

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? && @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

data/lib/composite_primary_keys/sanitization.rb

@@ -1,43 +1,43 @@
-module ActiveRecord
-  module Sanitization
-    module ClassMethods
-    #   def expand_hash_conditions_for_aggregates(attrs)
-    #     expanded_attrs = {}
-    #     attrs.each do |attr, value|
-    #       # CPK
-    #       # if aggregation = reflect_on_aggregation(attr.to_sym)
-    #       if attr.is_a?(CompositePrimaryKeys::CompositeKeys)
-    #         value = value.split('/') if value.is_a?(String)
-    #         attr.each_with_index do |key,i|
-    #           expanded_attrs[key] = value.respond_to?(:flatten) ? value.flatten[i] : value
-    #         end
-    #       elsif aggregation = reflect_on_aggregation(attr.to_sym)
-    #         mapping = aggregation.mapping
-    #         mapping.each do |field_attr, aggregate_attr|
-    #           if mapping.size == 1 && !value.respond_to?(aggregate_attr)
-    #             expanded_attrs[field_attr] = value
-    #           else
-    #             expanded_attrs[field_attr] = value.send(aggregate_attr)
-    #           end
-    #         end
-    #       else
-    #         expanded_attrs[attr] = value
-    #       end
-    #     end
-    #     expanded_attrs
-    #   end
-    #
-    #   def quoted_id
-    #     # CPK
-    #     # self.class.quote_value(@attributes[self.class.primary_key].value_for_database)
-    #     if self.composite?
-    #       [self.class.primary_keys, ids].transpose.map { |attr_name,id|
-    #         self.class.quote_value(@attributes[attr_name].value_for_database)
-    #       }
-    #     else
-    #       self.class.quote_value(@attributes[self.class.primary_key].value_for_database)
-    #     end
-    #   end
-    end
-  end
+module ActiveRecord
+  module Sanitization
+    module ClassMethods
+    #   def expand_hash_conditions_for_aggregates(attrs)
+    #     expanded_attrs = {}
+    #     attrs.each do |attr, value|
+    #       # CPK
+    #       # if aggregation = reflect_on_aggregation(attr.to_sym)
+    #       if attr.is_a?(CompositePrimaryKeys::CompositeKeys)
+    #         value = value.split('/') if value.is_a?(String)
+    #         attr.each_with_index do |key,i|
+    #           expanded_attrs[key] = value.respond_to?(:flatten) ? value.flatten[i] : value
+    #         end
+    #       elsif aggregation = reflect_on_aggregation(attr.to_sym)
+    #         mapping = aggregation.mapping
+    #         mapping.each do |field_attr, aggregate_attr|
+    #           if mapping.size == 1 && !value.respond_to?(aggregate_attr)
+    #             expanded_attrs[field_attr] = value
+    #           else
+    #             expanded_attrs[field_attr] = value.send(aggregate_attr)
+    #           end
+    #         end
+    #       else
+    #         expanded_attrs[attr] = value
+    #       end
+    #     end
+    #     expanded_attrs
+    #   end
+    #
+    #   def quoted_id
+    #     # CPK
+    #     # self.class.quote_value(@attributes[self.class.primary_key].value_for_database)
+    #     if self.composite?
+    #       [self.class.primary_keys, ids].transpose.map { |attr_name,id|
+    #         self.class.quote_value(@attributes[attr_name].value_for_database)
+    #       }
+    #     else
+    #       self.class.quote_value(@attributes[self.class.primary_key].value_for_database)
+    #     end
+    #   end
+    end
+  end
 end

data/lib/composite_primary_keys/table_metadata.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  class TableMetadata # :nodoc:
+    def associated_with?(table_name)
+      # CPK
+      # klass&._reflect_on_association(table_name) || klass&._reflect_on_association(table_name.singularize)
+      klass&._reflect_on_association(table_name) || klass&._reflect_on_association(table_name.to_s.singularize)
+    end
+  end
+end

data/lib/composite_primary_keys/transactions.rb

@@ -1,34 +1,34 @@
-module ActiveRecord
-  module Transactions
-    # Restore the new record state and id of a record that was previously saved by a call to save_record_state.
-    def restore_transaction_record_state(force_restore_state = false)
-      if restore_state = @_start_transaction_state
-        if force_restore_state || restore_state[:level] <= 1
-          @new_record = restore_state[:new_record]
-          @destroyed  = restore_state[:destroyed]
-          @attributes = restore_state[:attributes].map do |attr|
-            value = @attributes.fetch_value(attr.name)
-            attr = attr.with_value_from_user(value) if attr.value != value
-            attr
-          end
-          @mutations_from_database = nil
-          @mutations_before_last_save = nil
-
-          # CPK
-          if self.composite?
-            values = @primary_key.map {|attribute| @attributes.fetch_value(attribute)}
-            restore_id = restore_state[:id]
-            if values != restore_id
-              @primary_key.each_with_index do |attribute, i|
-                @attributes.write_from_user(attribute, restore_id[i])
-              end
-            end
-          elsif @attributes.fetch_value(@primary_key) != restore_state[:id]
-            @attributes.write_from_user(@primary_key, restore_state[:id])
-          end
-          freeze if restore_state[:frozen?]
-        end
-      end
-    end
-  end
-end
+module ActiveRecord
+  module Transactions
+    # Restore the new record state and id of a record that was previously saved by a call to save_record_state.
+    def restore_transaction_record_state(force_restore_state = false)
+      if restore_state = @_start_transaction_state
+        if force_restore_state || restore_state[:level] <= 1
+          @new_record = restore_state[:new_record]
+          @destroyed  = restore_state[:destroyed]
+          @attributes = restore_state[:attributes].map do |attr|
+            value = @attributes.fetch_value(attr.name)
+            attr = attr.with_value_from_user(value) if attr.value != value
+            attr
+          end
+          @mutations_from_database = nil
+          @mutations_before_last_save = nil
+
+          # CPK
+          if self.composite?
+            values = @primary_key.map {|attribute| @attributes.fetch_value(attribute)}
+            restore_id = restore_state[:id]
+            if values != restore_id
+              @primary_key.each_with_index do |attribute, i|
+                @attributes.write_from_user(attribute, restore_id[i])
+              end
+            end
+          elsif @attributes.fetch_value(@primary_key) != restore_state[:id]
+            @attributes.write_from_user(@primary_key, restore_state[:id])
+          end
+          freeze if restore_state[:frozen?]
+        end
+      end
+    end
+  end
+end

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 = 12
+    MAJOR = 13
     MINOR = 0
-    TINY  = 9
+    TINY  = 2
     STRING = [MAJOR, MINOR, TINY].join('.')
   end
 end