composite_primary_keys 12.0.0 → 12.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 69bb7bf55e5c40834cb9f38c6978cc7ad2564bc7e2884cc0181d7894f9ebba40
-  data.tar.gz: 31b2aa1fedc849533cbdebfbee1f2cd434a0a2ec37085a92b5592004d7a0ff4a
+  metadata.gz: b2a0ca9aa38fb1dfdca5c0974049eec9faf2c5703666a8e8de2ad28f6c78c7bc
+  data.tar.gz: 6384ddd8291fbd65e074965bfb70b8945c4ac6b556537973cc62561a86a0c609
 SHA512:
-  metadata.gz: 3b12c996e4d31037a31560dc6b69cd15ef422abfb6355c1331902b40ce1dff9e4faf59f36537c293b978571a09df875ee6628a94d6a24735fea20f84c370a2f3
-  data.tar.gz: eea6437fa46aab688e1b721e0cc3352b95ad318e1385d068399f30a111729fb0879a71071a3e94c56b652e8817e768651bd26f1f6a2a02066d2a0ece5b2e2f25
+  metadata.gz: 3c8a87f9676da79d514cd3dd2b21d7c1b523ddde1e13a2b37484e69ed4d93556e94fd725bc41642117338de66679932b69aff077c90c6c45d2026792439f4d5a
+  data.tar.gz: 5e393c7b725a757bef1a5b99efb9ef62612e3d11b7aa8dec15399684221a6a75f1b34908434b1471a0bc86a67814e7e387905d6e92885f7dddefb521668a7f9b

data/History.rdoc

@@ -1,6 +1,47 @@
-== 12.0.0 (?)
-* Update to ActiveRecord 6.0 (Hiroshi Kajisha, Alexandru Anca, Charlie Savage)
-* Update travis setup (Olle Jonsson)
+== 12.0.5 (2020-12-31)
+* Finally issue with SQLServer when tables are marked as exclude_output_inserted. See #535. (Charlie Savage)
+
+== 12.0.4 (2020-12-30)
+* Fix compatibility with Ruby Ruby 2.6 and below (ta1kt0me)
+* Finally get SQLServer mass updates and deletes working (Charlie Savage)
+* Fix MySQL mass updates and deletes that were broken by 12.0.3 (Charlie Savage)
+
+== 12.0.3 (2020-11-11)
+* Prevents infinite loops with gems which modify the 'attributes' method (Nicholas Guarino)
+* Improve delete_all and update_all queries (Charlie Savage)
+* Improve Oracle support (Charlie Savage)
+* Improve SQL Server support. Note delete_all and update_all queries still do not work due to
+  quirks in SQL Server syntax (Charlie Savage)
+* Improve support for polymorphic associations (Charlie Savage)
+* Update fixtures and tests to include a model that uses an :id column as part of a composite
+  key (Charlie Savage)
+* Fixed bug where id values were not correctly mapped between primary and foreign keys in associations (Charlie Savage)
+* Cleanup how the gem is loaded (Charlie Savage)
+* Remove older, unused or minimally used fixtures (Charlie Savage)
+
+== 12.0.2 (2020-05-19)
+* Remove deprecation warning for Ruby 2.7 due to keyword parameters (Alexandru Anca )
+* Use sqlite for default in tests (Charlie Savage)
+* Modernize gem tests by using Bundler (Charlie Savage)
+* Update travis for ruby 2.7 (Charlie Savage)
+* Port "Fix create record where one or more of the primary keys has a default value" from ar 5.2 branch (Charlie Savage)
+* Remove extra argument from sql_for_insert for SqlServer (tohae)
+
+== 12.0.1 (2019-11-25)
+* Convert attribute names to strings before checking for them in has_attribute? (Daniel de Haas)
+* Update the comment referring to the overridden Rails code (Daniel de Haas)
+
+== 12.0.0 (2019-09-03)
+* Update to ActiveRecord 6.0 (Hiroshi Kajisha, Alexandru Anca, Charlie Savage, Sammy Larbi)
+* Update travis setup (Olle Jonsson, Charlie Savage)
+
+==11.3.1 (2020-04-01)¶ ↑
+* Fix overriding AbstractReflection for activerecord 5.2.4 (Sergey Semyonov)
+* Fix handling CPK with fields containing comma (Sergey Semyonov)
+* Fixed incorrect SQL condition for joining by CPK (Sergey Semyonov)
+* Update travis.yml file (Sergey Semyonov)
+* Add tests for composite keys with default values (Daniel Wiklund)
+* Fix create record where one or more of the primary keys has a default value (Daniel Wiklund)
 
 == 11.2.0 (2019-03-16)
 * When creating new records, honor composite key autoincrementing fields if possible (Antti Pitkänen)

data/README.rdoc

@@ -113,7 +113,8 @@ divided into the following bundler groups:
 Since it is likely you do not have all the above databases installed on your computer, you want to install just the
 gems for your database.  For example, to test postgresql you would install the appropriate gems like this:
 
-  bundler install --without "mysql oracle sqlite sqlserver"
+  bundler config set --local without "mysql oracle sqlite sqlserver"
+  bundler install
 
 Once you have installed the appropriate gems, the next step is to create the test database. There is a rake
 command for each database. Using our example:
@@ -132,7 +133,7 @@ Finally, to run tests:
 
   rake postgresql:test
 
-Travis build status: {<img src="https://travis-ci.org/composite-primary-keys/composite_primary_keys.svg" alt="Build Status" />}[https://travis-ci.org/composite-primary-keys/composite_primary_keys]
+Travis build status: {<img src="https://travis-ci.com/composite-primary-keys/composite_primary_keys.svg" alt="Build Status" />}[https://travis-ci.com/composite-primary-keys/composite_primary_keys]
 
 === DB2
 

data/lib/composite_primary_keys.rb

@@ -21,16 +21,17 @@
 # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #++
 
-$:.unshift(File.dirname(__FILE__)) unless
-  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
-
 unless defined?(ActiveRecord)
   require 'rubygems'
-  gem 'activerecord', '6.0.0'
+  gem 'activerecord', '~>6.0.0'
   require 'active_record'
 end
 
-# AR files we override
+# ActiveModel files we override
+# _write_attribute
+require 'active_model/attribute_assignment'
+
+# ActiveRecord files we override
 require 'active_record/attribute_methods'
 require 'active_record/autosave_association'
 require 'active_record/counter_cache'
@@ -64,55 +65,54 @@ require 'active_record/connection_adapters/postgresql/database_statements'
 
 require 'active_record/relation/where_clause'
 
-# CPK files
-require 'composite_primary_keys/attribute_methods'
-require 'composite_primary_keys/autosave_association'
-require 'composite_primary_keys/persistence'
-require 'composite_primary_keys/base'
-require 'composite_primary_keys/core'
-require 'composite_primary_keys/composite_arrays'
-require 'composite_primary_keys/composite_predicates'
-require 'composite_primary_keys/counter_cache'
-require 'composite_primary_keys/fixtures'
-require 'composite_primary_keys/reflection'
-require 'composite_primary_keys/relation'
-require 'composite_primary_keys/sanitization'
-require 'composite_primary_keys/transactions'
-require 'composite_primary_keys/version'
-
-require 'composite_primary_keys/associations/association'
-require 'composite_primary_keys/associations/association_scope'
-require 'composite_primary_keys/associations/foreign_association'
-require 'composite_primary_keys/associations/has_many_association'
-require 'composite_primary_keys/associations/has_many_through_association'
-require 'composite_primary_keys/associations/join_dependency'
-require 'composite_primary_keys/associations/preloader/association'
-require 'composite_primary_keys/associations/collection_association'
-require 'composite_primary_keys/associations/through_association'
-
-require 'composite_primary_keys/attribute_methods/primary_key'
-require 'composite_primary_keys/attribute_methods/read'
-require 'composite_primary_keys/attribute_methods/write'
-require 'composite_primary_keys/nested_attributes'
-
-require 'composite_primary_keys/connection_adapters/abstract/database_statements'
-require 'composite_primary_keys/connection_adapters/abstract_adapter'
-require 'composite_primary_keys/connection_adapters/postgresql/database_statements'
-require 'composite_primary_keys/connection_adapters/sqlserver/database_statements'
-
-require 'composite_primary_keys/relation/batches'
-require 'composite_primary_keys/relation/where_clause'
-require 'composite_primary_keys/relation/calculations'
-require 'composite_primary_keys/relation/finder_methods'
-require 'composite_primary_keys/relation/predicate_builder/association_query_value'
-require 'composite_primary_keys/relation/query_methods'
-
-require 'composite_primary_keys/validations/uniqueness'
-
-require 'composite_primary_keys/composite_relation'
-
-require 'composite_primary_keys/arel/to_sql'
-
-# SQL Servers Support - uncomment these lines
-#require 'activerecord-sqlserver-adapter/arel/visitors/sqlserver'
-#require 'composite_primary_keys/arel/sqlserver'
+# CPK overrides
+require_relative 'composite_primary_keys/active_model/attribute_assignment'
+require_relative 'composite_primary_keys/attribute_methods'
+require_relative 'composite_primary_keys/autosave_association'
+require_relative 'composite_primary_keys/persistence'
+require_relative 'composite_primary_keys/base'
+require_relative 'composite_primary_keys/core'
+require_relative 'composite_primary_keys/composite_arrays'
+require_relative 'composite_primary_keys/composite_predicates'
+require_relative 'composite_primary_keys/counter_cache'
+require_relative 'composite_primary_keys/fixtures'
+require_relative 'composite_primary_keys/reflection'
+require_relative 'composite_primary_keys/relation'
+require_relative 'composite_primary_keys/sanitization'
+require_relative 'composite_primary_keys/transactions'
+require_relative 'composite_primary_keys/version'
+
+require_relative 'composite_primary_keys/associations/association'
+require_relative 'composite_primary_keys/associations/association_scope'
+require_relative 'composite_primary_keys/associations/foreign_association'
+require_relative 'composite_primary_keys/associations/has_many_association'
+require_relative 'composite_primary_keys/associations/has_many_through_association'
+require_relative 'composite_primary_keys/associations/join_dependency'
+require_relative 'composite_primary_keys/associations/preloader/association'
+require_relative 'composite_primary_keys/associations/collection_association'
+require_relative 'composite_primary_keys/associations/through_association'
+
+require_relative 'composite_primary_keys/attribute_methods/primary_key'
+require_relative 'composite_primary_keys/attribute_methods/read'
+require_relative 'composite_primary_keys/attribute_methods/write'
+require_relative 'composite_primary_keys/nested_attributes'
+
+require_relative 'composite_primary_keys/connection_adapters/abstract/database_statements'
+require_relative 'composite_primary_keys/connection_adapters/abstract_adapter'
+require_relative 'composite_primary_keys/connection_adapters/mysql/database_statements'
+require_relative 'composite_primary_keys/connection_adapters/postgresql/database_statements'
+require_relative 'composite_primary_keys/connection_adapters/sqlserver/database_statements'
+
+require_relative 'composite_primary_keys/relation/batches'
+require_relative 'composite_primary_keys/relation/where_clause'
+require_relative 'composite_primary_keys/relation/calculations'
+require_relative 'composite_primary_keys/relation/finder_methods'
+require_relative 'composite_primary_keys/relation/predicate_builder/association_query_value'
+require_relative 'composite_primary_keys/relation/query_methods'
+
+require_relative 'composite_primary_keys/validations/uniqueness'
+
+require_relative 'composite_primary_keys/composite_relation'
+
+require_relative 'composite_primary_keys/arel/to_sql'
+require_relative 'composite_primary_keys/arel/sqlserver'

data/lib/composite_primary_keys/active_model/attribute_assignment.rb

@@ -0,0 +1,19 @@
+module ActiveModel
+  module AttributeAssignment
+    def _assign_attribute(k, v)
+      # CPK. This is super ugly, but if a table has a composite key where one of the fields is named :id we need
+      # to handle it as a single value. Otherwise, we would call the id=(value) method which is expecting
+      # and array of values.
+      if k == 'id' && self.kind_of?(ActiveRecord::Base) && self.composite? && !self.column_for_attribute(k).null
+        self._write_attribute(k, v)
+      else
+        setter = :"#{k}="
+        if respond_to?(setter)
+          public_send(setter, v)
+        else
+          raise UnknownAttributeError.new(self, k)
+        end
+      end
+    end
+  end
+end

data/lib/composite_primary_keys/arel/sqlserver.rb

@@ -1,8 +1,6 @@
-require 'activerecord-sqlserver-adapter'
-
 module Arel
   module Visitors
-    class SQLServer
+    class SQLServer < Arel::Visitors::ToSql
       def make_Fetch_Possible_And_Deterministic o
         return if o.limit.nil? && o.offset.nil?
         t = table_From_Statement o

data/lib/composite_primary_keys/associations/through_association.rb

@@ -5,7 +5,8 @@ module ActiveRecord
 
       def construct_join_attributes(*records)
         # CPK
-        if source_reflection.klass.composite?
+        is_composite = self.source_reflection.polymorphic? ? source_reflection.active_record.composite? : source_reflection.klass.composite?
+        if is_composite
           ensure_mutable
 
           ids = records.map do |record|

data/lib/composite_primary_keys/attribute_methods.rb

@@ -2,8 +2,8 @@ module ActiveRecord
   module AttributeMethods
     def has_attribute?(attr_name)
       # CPK
-      # attributes.key?(attr_name)
-      Array(attr_name).all? {|single_attr| attributes.key?(single_attr) }
+      # @attributes.key?(attr_name.to_s)
+      Array(attr_name).all? {|single_attr| @attributes.key?(single_attr.to_s) }
     end
   end
 end

data/lib/composite_primary_keys/attribute_methods/primary_key.rb

@@ -1,6 +1,19 @@
 module ActiveRecord
   module AttributeMethods
     module PrimaryKey
+      module ClassMethods
+        def suppress_composite_primary_key(pk)
+          pk
+          # return pk unless pk.is_a?(Array)
+          #
+          # warn <<~WARNING
+          #         WARNING: Active Record does not support composite primary key.
+          #
+          #         #{table_name} has composite primary key. Composite primary key is ignored.
+          # WARNING
+        end
+      end
+
       # Returns the primary key previous value.
       def id_was
         sync_with_transaction_state

data/lib/composite_primary_keys/base.rb

@@ -89,6 +89,17 @@ module ActiveRecord
       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
@@ -123,7 +134,7 @@ module ActiveRecord
       end
 
       def to_param
-        persisted? ? to_key.join(CompositePrimaryKeys::ID_SEP) : nil
+        persisted? ? to_key.to_composite_keys.to_s : nil
       end
     end
   end

data/lib/composite_primary_keys/composite_arrays.rb

@@ -1,6 +1,7 @@
 module CompositePrimaryKeys
   ID_SEP     = ','
   ID_SET_SEP = ';'
+  ESCAPE_CHAR = '^'
 
   module ArrayExtension
     def to_composite_keys
@@ -8,12 +9,27 @@ module CompositePrimaryKeys
     end
   end
 
-  def self.normalize(ids)
+  # Convert mixed representation of CPKs (by strings or arrays) to normalized
+  # representation (just by arrays).
+  #
+  # `ids` is Array that may contain:
+  # 1. A CPK represented by an array or a string.
+  # 2. An array of CPKs represented by arrays or strings.
+  #
+  # There is an issue. Let `ids` contain an array with serveral strings. We can't distinguish case 1
+  # from case 2 there in general. E.g. the item can be an array containing appropriate number of strings,
+  # and each string can contain appropriate number of commas. We consider case 2 to win there.
+  def self.normalize(ids, cpk_size)
     ids.map do |id|
-      if id.is_a?(Array)
-        normalize(id)
-      elsif id.is_a?(String) && id.index(ID_SEP)
-        id.split(ID_SEP)
+      if Utils.cpk_as_array?(id, cpk_size) && id.any? { |item| !Utils.cpk_as_string?(item, cpk_size) }
+        # CPK as an array - case 1
+        id
+      elsif id.is_a?(Array)
+        # An array of CPKs - case 2
+        normalize(id, cpk_size)
+      elsif id.is_a?(String)
+        # CPK as a string - case 1
+        CompositeKeys.parse(id)
       else
         id
       end
@@ -27,25 +43,44 @@ module CompositePrimaryKeys
       when Array
         value.to_composite_keys
       when String
-        self.new(value.split(ID_SEP))
+        value.split(ID_SEP).map { |key| Utils.unescape_string_key(key) }.to_composite_keys
       else
         raise(ArgumentError, "Unsupported type: #{value}")
       end
     end
 
-    def in(other)
-      case other
-        when Arel::SelectManager
-          Arel::Nodes::In.new(self, other.ast)
-      end
+    def to_s
+      # Doing this makes it easier to parse Base#[](attr_name)
+      map { |key| Utils.escape_string_key(key.to_s) }.join(ID_SEP)
     end
+  end
 
+  module Utils
+    class << self
+      def escape_string_key(key)
+        key.gsub(Regexp.union(ESCAPE_CHAR, ID_SEP)) do |unsafe|
+          "#{ESCAPE_CHAR}#{unsafe.ord.to_s(16).upcase}"
+        end
+      end
 
-    def to_s
-      # Doing this makes it easier to parse Base#[](attr_name)
-      join(ID_SEP)
+      def unescape_string_key(key)
+        key.gsub(/#{Regexp.escape(ESCAPE_CHAR)}[0-9a-fA-F]{2}/) do |escaped|
+          char = escaped.slice(1, 2).hex.chr
+          (char == ESCAPE_CHAR || char == ID_SEP) ? char : escaped
+        end
+      end
+
+      def cpk_as_array?(value, pk_size)
+        # We don't permit Array to be an element of CPK.
+        value.is_a?(Array) && value.size == pk_size && value.none? { |item| item.is_a?(Array) }
+      end
+
+      def cpk_as_string?(value, pk_size)
+        value.is_a?(String) && value.count(ID_SEP) == pk_size - 1
+      end
     end
   end
+  private_constant :Utils
 end
 
 Array.send(:include, CompositePrimaryKeys::ArrayExtension)

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

@@ -5,9 +5,14 @@ module ActiveRecord
         sql, binds = to_sql_and_binds(arel, binds)
         value = exec_insert(sql, name, binds, pk, sequence_name)
 
-        # CPK
-        if value && pk.is_a?(Array)
-          id_value || value.rows.first
+        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

data/lib/composite_primary_keys/connection_adapters/abstract_adapter.rb

@@ -4,7 +4,7 @@ module ActiveRecord
       def quote_column_names(name)
         Array(name).map do |col|
           quote_column_name(col.to_s)
-        end.join(CompositePrimaryKeys::ID_SEP)
+        end.to_composite_keys.to_s
       end
     end
   end

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module MySQL
+      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)
+
+          # CPK
+          if pk.is_a?(Array)
+            pk.map do |key|
+              column = column_for(arel.ast.relation.name, key)
+              column.auto_increment? ? last_inserted_id(value) : nil
+            end
+          else
+            id_value || last_inserted_id(value)
+          end
+        end
+      end
+    end
+  end
+end