composite_primary_keys 12.0.3 → 12.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1c7ee90af81fc2755ecd8b49d91808047736a1ec2d99fea0961bdc6813e9c6c1
-  data.tar.gz: e0ff0a387dbd7ff3b7d3c0777ecf1fd54d4a5637128179c6a0788f71481079c5
+  metadata.gz: 7659741f962a45ac7c557ae8dcb77a01bb361bd46ac8032f9dd4c05a89b14962
+  data.tar.gz: e88d4c5c7e8dee12e00b8d339ec5397d28f104bfb8ea526e979ad45101f0225d
 SHA512:
-  metadata.gz: e9a6b4eb511b992f4ed4aa971fb6eb8a19af49cff1b06998f4d7093a155f2b6c39674c444d70595833ed887bbe2406d665f5c48751316c743597ae442c0d44fd
-  data.tar.gz: dbdb54e9141e4d8dd959712f9f7f52f43ce22e7b184f0cc274769ca241418af4fd9775c7532fa492f1988c61fcb6a2b69143fe94889ebbf1b9a76c3b30cb0bdd
+  metadata.gz: f99e8ab455cf07e5030a94cf87566143486027e359ca97709aca115350abe0f2e263b4d459134c1f032fd14e046a598e144e7107b5ba2d41d5ad182591cb205e
+  data.tar.gz: 0ace5f54f8e1338393cf1e86e24ebe7fa7e414215fe7fdcfb2f4c7059ae6ebf40f38e4fc6aca3a20357e5794f4dbdb93d668da24c3aa8eb947b0ea35f9505f63

data/History.rdoc

@@ -1,3 +1,8 @@
+== 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)

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

@@ -11,7 +11,7 @@ module ActiveRecord
           # CPK
           if pk.is_a?(Array)
             pk.map do |key|
-              column = self.column_for(arel.ast.relation.name, key)
+              column = column_for(arel.ast.relation.name, key)
               column.auto_increment? ? last_inserted_id(value) : nil
             end
           else

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/relation.rb

@@ -28,7 +28,7 @@ module ActiveRecord
       # CPK
       if @klass.composite?
         stmt.table(arel_table)
-        cpk_in_subquery(stmt)
+        cpk_subquery(stmt)
       else
         stmt.table(arel.join_sources.empty? ? table : arel.source)
         stmt.key = arel_attribute(primary_key)
@@ -71,7 +71,7 @@ module ActiveRecord
 
       if @klass.composite?
         stmt.from(arel_table)
-        cpk_in_subquery(stmt)
+        cpk_subquery(stmt)
       else
         stmt.from(arel.join_sources.empty? ? table : arel.source)
         stmt.key = arel_attribute(primary_key)
@@ -89,6 +89,29 @@ module ActiveRecord
     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
@@ -103,25 +126,68 @@ module ActiveRecord
       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)
-      # 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_attributes = primary_keys.map do |key|
+        arel_attribute(key)
+      end.to_composite_keys
 
-      # Setup the subquery
-      subquery = arel.clone
-      subquery.projections = primary_keys.map do |key|
-        arel_table[key]
-      end
+      # 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 = aliased_table[key]
-        inner_attribute = arel_table[key]
+        outer_attribute = arel_table[key]
+        inner_attribute = aliased_table[key]
         where = outer_attribute.eq(inner_attribute)
-        subquery.where(where)
+        subselect.where(where)
       end
-      stmt.wheres = [Arel::Nodes::Exists.new(subquery)]
+      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

data/lib/composite_primary_keys/relation/finder_methods.rb

@@ -96,7 +96,7 @@ module CompositePrimaryKeys
         case ids.size
         when 0
           error_message = "Couldn't find #{model_name} without an ID"
-          raise RecordNotFound.new(error_message, model_name, primary_key)
+          raise ::ActiveRecord::RecordNotFound.new(error_message, model_name, primary_key)
         when 1
           result = find_one(ids.first)
           expects_array ? [ result ] : result

data/lib/composite_primary_keys/version.rb

@@ -2,7 +2,7 @@ module CompositePrimaryKeys
   module VERSION
     MAJOR = 12
     MINOR = 0
-    TINY  = 3
+    TINY  = 4
     STRING = [MAJOR, MINOR, TINY].join('.')
   end
 end

data/test/abstract_unit.rb

@@ -1,4 +1,4 @@
-spec_name = ENV['ADAPTER'] || 'mysql'
+spec_name = ENV['ADAPTER'] || 'sqlite'
 require 'bundler'
 require 'minitest/autorun'
 

data/test/fixtures/db_definitions/mysql.sql

@@ -72,7 +72,7 @@ create table readings (
     primary key (id)
 );
 
-create table groups (
+create table `groups` (
     id int not null auto_increment,
     name varchar(50) not null,
     primary key (id)

data/test/test_find.rb

@@ -74,6 +74,18 @@ class TestFind < ActiveSupport::TestCase
     assert_equal(with_quoted_identifiers(expected), error.message)
   end
 
+  def test_find_with_invalid_ids
+    assert_raise(::ActiveRecord::RecordNotFound) do
+      Suburb.find([-1, -1])
+    end
+  end
+
+  def test_find_with_no_ids
+    assert_raise(::ActiveRecord::RecordNotFound) do
+      Suburb.find
+    end
+  end
+
   def test_find_last_suburb
     suburb = Suburb.last
     assert_equal([2,2], suburb.id)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: composite_primary_keys
 version: !ruby/object:Gem::Version
-  version: 12.0.3
+  version: 12.0.4
 platform: ruby
 authors:
 - Charlie Savage
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-11-12 00:00:00.000000000 Z
+date: 2020-12-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord