composite_primary_keys 12.0.2 → 12.0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 50263520fdb0be5f5bc2828aca6b130603ea4e31548efbe373505db324cf1c54
-  data.tar.gz: c1511083ac64af445eceddf5b89e803a247bc3585db25f85b5c7befef89c6432
+  metadata.gz: 9669e29673330db679efb20ca257d87ce1cdad3d6fe69681a54ac706a0cd5f82
+  data.tar.gz: db2ba7fcc0f91b8cd6c54c177dd5ca9d7cb7d04b47f1ec42e43691283a1f16d1
 SHA512:
-  metadata.gz: 6cb036105bb0b8302dbbc5850641197bf7b158a8a2af5b366cf645abf6ffa97790eb5bca350e49475960ba92a1280ef6d7641552c6f58b79202540614a59ed72
-  data.tar.gz: 4d10a81f280b21611f39cb316f02c21f7a07636fecc379668e6639f776125cc9f7f015c7a4be876f3cedeb7d85788e6088cab1be29ec0be48ca40567a52fdd16
+  metadata.gz: 6bfb9ac058f43b9e18499e7517029e41278272f91955058eaf87d3ecac4649906e84ee9e01a8b6466128cfe998bfe94eec6fbb7e9f0d1945a3e9a749a6990a93
+  data.tar.gz: 435cb41a8e3499508285444be01f8c585c747f98a0c6174353ac31f3ed147a8f165478dfce8bd975a10142d7357bdcee7121f9726ced186ceb2062e0bde36625

data/History.rdoc

@@ -1,3 +1,33 @@
+== 12.0.7 (2021-02-15)
+* Switch to GitHub actions (ta1kt0me)
+* Fix MySQL/MariaDB query cache issue bug introduced in version 12.0.3 - see #539 (Charlie Savage)
+* Do a better job of supporting composite keys with an auto incrementing field for
+  MySQL and MariaDB (Charlie Savage)
+
+== 12.0.6 (2021-01-04)
+* Fix issue when calling in_batches without a block (Charlie Savage)
+
+== 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)

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'
   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'
@@ -61,58 +62,58 @@ require 'active_record/nested_attributes'
 require 'active_record/connection_adapters/abstract/database_statements'
 require 'active_record/connection_adapters/abstract_adapter'
 require 'active_record/connection_adapters/postgresql/database_statements'
+require 'active_record/connection_adapters/mysql/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

@@ -3,7 +3,7 @@ module ActiveRecord
     def has_attribute?(attr_name)
       # CPK
       # @attributes.key?(attr_name.to_s)
-      Array(attr_name).all? {|single_attr| attributes.key?(single_attr.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

data/lib/composite_primary_keys/composite_arrays.rb

@@ -49,14 +49,6 @@ module CompositePrimaryKeys
       end
     end
 
-    def in(other)
-      case other
-        when Arel::SelectManager
-          Arel::Nodes::In.new(self, other.ast)
-      end
-    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)

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

@@ -5,11 +5,31 @@ 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
+        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
-          id_value || last_inserted_id(value)
+          last_inserted_id(value)
         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

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

@@ -3,19 +3,40 @@ module ActiveRecord
     module SQLServer
       module DatabaseStatements
         def sql_for_insert(sql, pk, binds)
-          sql = if pk && self.class.use_output_inserted
-            # CPK
-            # quoted_pk = SQLServer::Utils.extract_identifiers(pk).quoted
-            # sql.insert sql.index(/ (DEFAULT )?VALUES/), " OUTPUT INSERTED.#{quoted_pk}"
-            quoted_pks = [pk].flatten.map {|pk| "INSERTED.#{SQLServer::Utils.extract_identifiers(pk).quoted}"}
-            sql.dup.insert sql.index(/ (DEFAULT )?VALUES/), " OUTPUT #{quoted_pks.join(", ")}"
-          else
-            "#{sql}; SELECT CAST(SCOPE_IDENTITY() AS bigint) AS Ident"
+          if pk.nil?
+            table_name = query_requires_identity_insert?(sql)
+            pk = primary_key(table_name)
           end
 
-          # CPK
-          # super
-          [sql, binds]
+          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

data/lib/composite_primary_keys/core.rb

@@ -40,7 +40,7 @@ module ActiveRecord
 
         record = statement.execute([id], connection)&.first
         unless record
-          raise RecordNotFound.new("Couldn't find #{name} with '#{key}'=#{id}", name, key, id)
+          raise ::ActiveRecord::RecordNotFound.new("Couldn't find #{name} with '#{key}'=#{id}", name, key, id)
         end
         record
       end

data/lib/composite_primary_keys/persistence.rb

@@ -65,8 +65,8 @@ module ActiveRecord
       )
 
       # CPK
-      if self.composite? && self.id.compact.empty?
-        self.id = self.id.zip(Array(new_id)).map {|id1, id2| (id1 || id2)}
+      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