composite_primary_keys 12.0.2 → 12.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 50263520fdb0be5f5bc2828aca6b130603ea4e31548efbe373505db324cf1c54
-  data.tar.gz: c1511083ac64af445eceddf5b89e803a247bc3585db25f85b5c7befef89c6432
+  metadata.gz: 1c7ee90af81fc2755ecd8b49d91808047736a1ec2d99fea0961bdc6813e9c6c1
+  data.tar.gz: e0ff0a387dbd7ff3b7d3c0777ecf1fd54d4a5637128179c6a0788f71481079c5
 SHA512:
-  metadata.gz: 6cb036105bb0b8302dbbc5850641197bf7b158a8a2af5b366cf645abf6ffa97790eb5bca350e49475960ba92a1280ef6d7641552c6f58b79202540614a59ed72
-  data.tar.gz: 4d10a81f280b21611f39cb316f02c21f7a07636fecc379668e6639f776125cc9f7f015c7a4be876f3cedeb7d85788e6088cab1be29ec0be48ca40567a52fdd16
+  metadata.gz: e9a6b4eb511b992f4ed4aa971fb6eb8a19af49cff1b06998f4d7093a155f2b6c39674c444d70595833ed887bbe2406d665f5c48751316c743597ae442c0d44fd
+  data.tar.gz: dbdb54e9141e4d8dd959712f9f7f52f43ce22e7b184f0cc274769ca241418af4fd9775c7532fa492f1988c61fcb6a2b69143fe94889ebbf1b9a76c3b30cb0bdd

data/History.rdoc

@@ -1,3 +1,16 @@
+== 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'
@@ -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

@@ -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,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/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 = self.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,37 @@ 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
+                    <<~SQL.squish
+                      DECLARE @ssaIdInsertTable table (#{quoted_pk} #{id_sql_type});
+                      # CPK
+                      # #{sql.dup.insert sql.index(/ (DEFAULT )?VALUES/), " OUTPUT INSERTED.#{quoted_pk} INTO @ssaIdInsertTable"}
+                      #{sql.dup.insert sql.index(/ (DEFAULT )?VALUES/), " OUTPUT INSERTED.#{quoted_pk.join(', INSERTED.')} INTO @ssaIdInsertTable"}
+                      SELECT CAST(#{quoted_pk.join(',')} AS #{id_sql_type}) 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/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

data/lib/composite_primary_keys/relation.rb

@@ -27,15 +27,8 @@ module ActiveRecord
       stmt = Arel::UpdateManager.new
       # CPK
       if @klass.composite?
-        stmt.table(table)
-
-        arel_attributes = primary_keys.map do |key|
-          arel_attribute(key)
-        end.to_composite_keys
-
-        subselect = subquery_for(arel_attributes, arel)
-
-        stmt.wheres = [arel_attributes.in(subselect)]
+        stmt.table(arel_table)
+        cpk_in_subquery(stmt)
       else
         stmt.table(arel.join_sources.empty? ? table : arel.source)
         stmt.key = arel_attribute(primary_key)
@@ -75,22 +68,16 @@ module ActiveRecord
       end
 
       stmt = Arel::DeleteManager.new
-      # CPK
-      if @klass.composite?
-        stmt.from(table)
-
-        arel_attributes = primary_keys.map do |key|
-          arel_attribute(key)
-        end.to_composite_keys
 
-        subselect = subquery_for(arel_attributes, arel)
-
-        stmt.wheres = [arel_attributes.in(subselect)]
+      if @klass.composite?
+        stmt.from(arel_table)
+        cpk_in_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)
@@ -102,17 +89,39 @@ module ActiveRecord
     end
 
     # CPK
-    def subquery_for(key, select)
-      subselect = select.clone
-      subselect.projections = key
+    def cpk_in_subquery(stmt)
+      # Setup the subquery
+      subquery = arel.clone
+      subquery.projections = primary_keys.map do |key|
+        arel_table[key]
+      end
 
-      # Materialize subquery by adding distinct
-      # to work with MySQL 5.7.6 which sets optimizer_switch='derived_merge=on'
-      subselect.distinct unless select.limit || select.offset || select.orders.any?
+      where_fields = primary_keys.map do |key|
+        arel_table[key]
+      end
+      where = Arel::Nodes::Grouping.new(where_fields).in(subquery)
+      stmt.wheres = [where]
+    end
 
-      key_name = Array(key).map {|a_key| a_key.name }.join(',')
+    def cpk_exists_subquery(stmt)
+      # Alias the outer table so we can join to in from the subquery
+      aliased_table = arel_table.alias("cpk_outer_relation")
+      stmt.table(aliased_table)
 
-      Arel::SelectManager.new(subselect.as("__active_record_temp")).project(Arel.sql(key_name))
+      # Setup the subquery
+      subquery = arel.clone
+      subquery.projections = primary_keys.map do |key|
+        arel_table[key]
+      end
+
+      # Setup correlation to the outer query via where clauses
+      primary_keys.map do |key|
+        outer_attribute = aliased_table[key]
+        inner_attribute = arel_table[key]
+        where = outer_attribute.eq(inner_attribute)
+        subquery.where(where)
+      end
+      stmt.wheres = [Arel::Nodes::Exists.new(subquery)]
     end
   end
 end