composite_primary_keys 12.0.8 → 13.0.1

data/lib/composite_primary_keys/base.rb

@@ -1,141 +1,141 @@
-module ActiveRecord
-  class CompositeKeyError < StandardError #:nodoc:
-  end
-
-  class Base
-    INVALID_FOR_COMPOSITE_KEYS = 'Not appropriate for composite primary keys'
-    NOT_IMPLEMENTED_YET        = 'Not implemented for composite primary keys yet'
-
-    class << self
-      alias_method :primary_key_without_composite_key_support=, :primary_key=
-      def primary_key=(keys)
-        unless keys.kind_of?(Array)
-          self.primary_key_without_composite_key_support = keys
-          return
-        end
-
-        @primary_keys = keys.map { |k| k.to_s }.to_composite_keys
-
-        class_eval <<-EOV
-          extend  CompositeClassMethods
-          include CompositeInstanceMethods
-        EOV
-      end
-      alias_method :primary_keys=, :primary_key=
-
-      def set_primary_keys(*keys)
-        ActiveSupport::Deprecation.warn(
-            "Calling set_primary_keys is deprecated. Please use `self.primary_keys = keys` instead."
-        )
-
-        keys = keys.first if keys.first.is_a?(Array)
-        if keys.length == 1
-          self.primary_key = keys.first
-        else
-          self.primary_keys = keys
-        end
-      end
-
-      def composite?
-        false
-      end
-    end
-
-    def composite?
-      self.class.composite?
-    end
-
-    module CompositeClassMethods
-      def primary_keys
-        @primary_keys = reset_primary_keys unless defined? @primary_keys
-        @primary_keys
-      end
-
-      # Don't like this method name, but its modeled after how AR does it
-      def reset_primary_keys #:nodoc:
-        if self == base_class
-          # CPK
-          self.primary_keys = get_primary_key(base_class.name)
-        else
-          self.primary_keys = base_class.primary_keys
-        end
-      end
-
-      def primary_key
-        primary_keys
-      end
-
-      def primary_key=(keys)
-        self.primary_keys = keys
-      end
-
-      def composite?
-        true
-      end
-
-      #ids_to_s([[1,2],[7,3]]) -> "(1,2),(7,3)"
-      #ids_to_s([[1,2],[7,3]], ',', ';') -> "1,2;7,3"
-      def ids_to_s(many_ids, id_sep = CompositePrimaryKeys::ID_SEP, list_sep = ',', left_bracket = '(', right_bracket = ')')
-        many_ids.map {|ids| "#{left_bracket}#{CompositePrimaryKeys::CompositeKeys.new(ids)}#{right_bracket}"}.join(list_sep)
-      end
-    end
-
-    module CompositeInstanceMethods
-      # A model instance's primary keys is always available as model.ids
-      # whether you name it the default 'id' or set it to something else.
-      def id
-        attr_names = self.class.primary_keys
-        ::CompositePrimaryKeys::CompositeKeys.new(attr_names.map { |attr_name| read_attribute(attr_name) })
-      end
-      alias_method :ids, :id
-
-      # This is overridden purely for json serialization support. If the model is composite
-      # and one of the keys is id, then we don't want to call the id method, instead we want
-      # to get the id attribute value
-      def read_attribute_for_serialization(attribute)
-        if self.composite? && attribute == 'id'
-          read_attribute(attribute)
-        else
-          send(attribute)
-        end
-      end
-
-      def ids_hash
-        self.class.primary_key.zip(ids).inject(Hash.new) do |hash, (key, value)|
-          hash[key] = value
-          hash
-        end
-      end
-
-      def id_before_type_cast
-        self.class.primary_keys.map do |key|
-          self.read_attribute_before_type_cast(key)
-        end
-      end
-
-      # Sets the primary ID.
-      def id=(ids)
-        ids = CompositePrimaryKeys::CompositeKeys.parse(ids)
-        unless ids.length == self.class.primary_keys.length
-          raise "#{self.class}.id= requires #{self.class.primary_keys.length} ids"
-        end
-        [self.class.primary_keys, ids].transpose.each {|key, an_id| write_attribute(key , an_id)}
-        id
-      end
-
-      def can_change_primary_key_values?
-        false
-      end
-
-      # Returns this record's primary keys values in an Array
-      # if any value is available
-      def to_key
-        ids.to_a if !ids.compact.empty? # XXX Maybe use primary_keys with send instead of ids
-      end
-
-      def to_param
-        persisted? ? to_key.to_composite_keys.to_s : nil
-      end
-    end
-  end
-end
+module ActiveRecord
+  class CompositeKeyError < StandardError #:nodoc:
+  end
+
+  class Base
+    INVALID_FOR_COMPOSITE_KEYS = 'Not appropriate for composite primary keys'
+    NOT_IMPLEMENTED_YET        = 'Not implemented for composite primary keys yet'
+
+    class << self
+      alias_method :primary_key_without_composite_key_support=, :primary_key=
+      def primary_key=(keys)
+        unless keys.kind_of?(Array)
+          self.primary_key_without_composite_key_support = keys
+          return
+        end
+
+        @primary_keys = keys.map { |k| k.to_s }.to_composite_keys
+
+        class_eval <<-EOV
+          extend  CompositeClassMethods
+          include CompositeInstanceMethods
+        EOV
+      end
+      alias_method :primary_keys=, :primary_key=
+
+      def set_primary_keys(*keys)
+        ActiveSupport::Deprecation.warn(
+            "Calling set_primary_keys is deprecated. Please use `self.primary_keys = keys` instead."
+        )
+
+        keys = keys.first if keys.first.is_a?(Array)
+        if keys.length == 1
+          self.primary_key = keys.first
+        else
+          self.primary_keys = keys
+        end
+      end
+
+      def composite?
+        false
+      end
+    end
+
+    def composite?
+      self.class.composite?
+    end
+
+    module CompositeClassMethods
+      def primary_keys
+        @primary_keys = reset_primary_keys unless defined? @primary_keys
+        @primary_keys
+      end
+
+      # Don't like this method name, but its modeled after how AR does it
+      def reset_primary_keys #:nodoc:
+        if self == base_class
+          # CPK
+          self.primary_keys = get_primary_key(base_class.name)
+        else
+          self.primary_keys = base_class.primary_keys
+        end
+      end
+
+      def primary_key
+        primary_keys
+      end
+
+      def primary_key=(keys)
+        self.primary_keys = keys
+      end
+
+      def composite?
+        true
+      end
+
+      #ids_to_s([[1,2],[7,3]]) -> "(1,2),(7,3)"
+      #ids_to_s([[1,2],[7,3]], ',', ';') -> "1,2;7,3"
+      def ids_to_s(many_ids, id_sep = CompositePrimaryKeys::ID_SEP, list_sep = ',', left_bracket = '(', right_bracket = ')')
+        many_ids.map {|ids| "#{left_bracket}#{CompositePrimaryKeys::CompositeKeys.new(ids)}#{right_bracket}"}.join(list_sep)
+      end
+    end
+
+    module CompositeInstanceMethods
+      # A model instance's primary keys is always available as model.ids
+      # whether you name it the default 'id' or set it to something else.
+      def id
+        attr_names = self.class.primary_keys
+        ::CompositePrimaryKeys::CompositeKeys.new(attr_names.map { |attr_name| read_attribute(attr_name) })
+      end
+      alias_method :ids, :id
+
+      # This is overridden purely for json serialization support. If the model is composite
+      # and one of the keys is id, then we don't want to call the id method, instead we want
+      # to get the id attribute value
+      def read_attribute_for_serialization(attribute)
+        if self.composite? && attribute == 'id'
+          read_attribute(attribute)
+        else
+          send(attribute)
+        end
+      end
+
+      def ids_hash
+        self.class.primary_key.zip(ids).inject(Hash.new) do |hash, (key, value)|
+          hash[key] = value
+          hash
+        end
+      end
+
+      def id_before_type_cast
+        self.class.primary_keys.map do |key|
+          self.read_attribute_before_type_cast(key)
+        end
+      end
+
+      # Sets the primary ID.
+      def id=(ids)
+        ids = CompositePrimaryKeys::CompositeKeys.parse(ids)
+        unless ids.length == self.class.primary_keys.length
+          raise "#{self.class}.id= requires #{self.class.primary_keys.length} ids"
+        end
+        [self.class.primary_keys, ids].transpose.each {|key, an_id| write_attribute(key , an_id)}
+        id
+      end
+
+      def can_change_primary_key_values?
+        false
+      end
+
+      # Returns this record's primary keys values in an Array
+      # if any value is available
+      def to_key
+        ids.to_a if !ids.compact.empty? # XXX Maybe use primary_keys with send instead of ids
+      end
+
+      def to_param
+        persisted? ? to_key.to_composite_keys.to_s : nil
+      end
+    end
+  end
+end

data/lib/composite_primary_keys/composite_predicates.rb

@@ -32,7 +32,8 @@ module CompositePrimaryKeys
     end
 
     def cpk_id_predicate(table, keys, values)
-      eq_predicates = keys.zip(values).map do |key, value|
+      # We zip on values then keys in case values are not provided for each key field
+      eq_predicates = values.zip(keys).map do |value, key|
         table[key].eq(value)
       end
       cpk_and_predicate(eq_predicates)

data/lib/composite_primary_keys/connection_adapters/abstract/database_statements.rb

@@ -1,22 +1,37 @@
-module ActiveRecord
-  module ConnectionAdapters
-    module DatabaseStatements
-      def insert(arel, name = nil, pk = nil, id_value = nil, sequence_name = nil, binds = [])
-        sql, binds = to_sql_and_binds(arel, binds)
-        value = exec_insert(sql, name, binds, pk, sequence_name)
-
-        if pk.is_a?(Array) && !value.empty?
-          # This is a CPK model and the query result is not empty. Thus we can figure out the new ids for each
-          # auto incremented field
-          id_value || pk.map {|key| value.first[key]}
-        elsif pk.is_a?(Array)
-          # This is CPK, but we don't know what autoincremented fields were updated. So return nil, which means
-          # the existing id_value of the model will be used.
-          id_value || Array.new(pk.size)
-        else
-          id_value || last_inserted_id(value)
-        end
-      end
-    end
-  end
-end
+module ActiveRecord
+  module ConnectionAdapters
+    module DatabaseStatements
+      def insert(arel, name = nil, pk = nil, id_value = nil, sequence_name = nil, binds = [])
+        sql, binds = to_sql_and_binds(arel, binds)
+        value = exec_insert(sql, name, binds, pk, sequence_name)
+
+        return id_value if id_value
+
+        if pk.is_a?(Array) && !value.empty?
+          # This is a CPK model and the query result is not empty. Thus we can figure out the new ids for each
+          # auto incremented field
+          pk.map {|key| value.first[key]}
+        elsif pk.is_a?(Array)
+          # This is CPK, but we don't know what autoincremented fields were updated.
+          result = Array.new(pk.size)
+
+          # Is there an autoincrementing field?
+          auto_key = pk.find do |key|
+            attribute = arel.ast.relation[key]
+            column = column_for_attribute(attribute)
+            if column.respond_to?(:auto_increment?)
+              column.auto_increment?
+            end
+          end
+
+          if auto_key
+            result[pk.index(auto_key)] = last_inserted_id(value)
+          end
+          result
+        else
+          last_inserted_id(value)
+        end
+      end
+    end
+  end
+end

data/lib/composite_primary_keys/connection_adapters/sqlserver/database_statements.rb

@@ -1,44 +1,44 @@
-module ActiveRecord
-  module ConnectionAdapters
-    module SQLServer
-      module DatabaseStatements
-        def sql_for_insert(sql, pk, binds)
-          if pk.nil?
-            table_name = query_requires_identity_insert?(sql)
-            pk = primary_key(table_name)
-          end
-
-          sql = if pk && use_output_inserted? && !database_prefix_remote_server?
-                  # CPK
-                  #quoted_pk = SQLServer::Utils.extract_identifiers(pk).quoted
-                  quoted_pk = Array(pk).map {|subkey| SQLServer::Utils.extract_identifiers(subkey).quoted}
-
-                  table_name ||= get_table_name(sql)
-                  exclude_output_inserted = exclude_output_inserted_table_name?(table_name, sql)
-                  if exclude_output_inserted
-                    id_sql_type = exclude_output_inserted.is_a?(TrueClass) ? "bigint" : exclude_output_inserted
-                    # CPK
-                    # <<~SQL.squish
-                    #   DECLARE @ssaIdInsertTable table (#{quoted_pk} #{id_sql_type});
-                    #   #{sql.dup.insert sql.index(/ (DEFAULT )?VALUES/), " OUTPUT INSERTED.#{quoted_pk} INTO @ssaIdInsertTable"}
-                    #   SELECT CAST(#{quoted_pk.join(',')} AS #{id_sql_type}) FROM @ssaIdInsertTable
-                    # SQL
-                    <<~SQL.squish
-                      DECLARE @ssaIdInsertTable table (#{quoted_pk.map {|subkey| "#{subkey} #{id_sql_type}"}.join(", ")});
-                      #{sql.dup.insert sql.index(/ (DEFAULT )?VALUES/), " OUTPUT INSERTED.#{quoted_pk.join(', INSERTED.')} INTO @ssaIdInsertTable"}
-                      SELECT #{quoted_pk.map {|subkey| "CAST(#{subkey} AS #{id_sql_type}) #{subkey}"}.join(", ")} FROM @ssaIdInsertTable
-                    SQL
-                  else
-                    # CPK
-                    # sql.dup.insert sql.index(/ (DEFAULT )?VALUES/), " OUTPUT INSERTED.#{quoted_pk}"
-                    sql.dup.insert sql.index(/ (DEFAULT )?VALUES/), " OUTPUT INSERTED.#{quoted_pk.join(', INSERTED.')}"
-                  end
-                else
-                  "#{sql}; SELECT CAST(SCOPE_IDENTITY() AS bigint) AS Ident"
-                end
-          super
-        end
-      end
-    end
-  end
-end
+module ActiveRecord
+  module ConnectionAdapters
+    module SQLServer
+      module DatabaseStatements
+        def sql_for_insert(sql, pk, binds)
+          if pk.nil?
+            table_name = query_requires_identity_insert?(sql)
+            pk = primary_key(table_name)
+          end
+
+          sql = if pk && use_output_inserted? && !database_prefix_remote_server?
+                  # CPK
+                  #quoted_pk = SQLServer::Utils.extract_identifiers(pk).quoted
+                  quoted_pk = Array(pk).map {|subkey| SQLServer::Utils.extract_identifiers(subkey).quoted}
+
+                  table_name ||= get_table_name(sql)
+                  exclude_output_inserted = exclude_output_inserted_table_name?(table_name, sql)
+                  if exclude_output_inserted
+                    id_sql_type = exclude_output_inserted.is_a?(TrueClass) ? "bigint" : exclude_output_inserted
+                    # CPK
+                    # <<~SQL.squish
+                    #   DECLARE @ssaIdInsertTable table (#{quoted_pk} #{id_sql_type});
+                    #   #{sql.dup.insert sql.index(/ (DEFAULT )?VALUES/), " OUTPUT INSERTED.#{quoted_pk} INTO @ssaIdInsertTable"}
+                    #   SELECT CAST(#{quoted_pk.join(',')} AS #{id_sql_type}) FROM @ssaIdInsertTable
+                    # SQL
+                    <<~SQL.squish
+                      DECLARE @ssaIdInsertTable table (#{quoted_pk.map {|subkey| "#{subkey} #{id_sql_type}"}.join(", ")});
+                      #{sql.dup.insert sql.index(/ (DEFAULT )?VALUES/), " OUTPUT INSERTED.#{quoted_pk.join(', INSERTED.')} INTO @ssaIdInsertTable"}
+                      SELECT #{quoted_pk.map {|subkey| "CAST(#{subkey} AS #{id_sql_type}) #{subkey}"}.join(", ")} FROM @ssaIdInsertTable
+                    SQL
+                  else
+                    # CPK
+                    # sql.dup.insert sql.index(/ (DEFAULT )?VALUES/), " OUTPUT INSERTED.#{quoted_pk}"
+                    sql.dup.insert sql.index(/ (DEFAULT )?VALUES/), " OUTPUT INSERTED.#{quoted_pk.join(', INSERTED.')}"
+                  end
+                else
+                  "#{sql}; SELECT CAST(SCOPE_IDENTITY() AS bigint) AS Ident"
+                end
+          super
+        end
+      end
+    end
+  end
+end

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])