composite_primary_keys 12.0.3 → 12.0.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1c7ee90af81fc2755ecd8b49d91808047736a1ec2d99fea0961bdc6813e9c6c1
-  data.tar.gz: e0ff0a387dbd7ff3b7d3c0777ecf1fd54d4a5637128179c6a0788f71481079c5
+  metadata.gz: 2465cca0fa83a628e24f3221e88095690295c99b2bf46818bd2ebd76df8300b5
+  data.tar.gz: a22c2b61575c26e23e51b314c05c158663c26ce7a9c64fb56019d596edc6a844
 SHA512:
-  metadata.gz: e9a6b4eb511b992f4ed4aa971fb6eb8a19af49cff1b06998f4d7093a155f2b6c39674c444d70595833ed887bbe2406d665f5c48751316c743597ae442c0d44fd
-  data.tar.gz: dbdb54e9141e4d8dd959712f9f7f52f43ce22e7b184f0cc274769ca241418af4fd9775c7532fa492f1988c61fcb6a2b69143fe94889ebbf1b9a76c3b30cb0bdd
+  metadata.gz: 3147006b49f98c3d1e88dbec56590fad63c13506634427361e14e06d611e75666c89c48c3e9151d174dc075d850a238285be6bc62739d8971d7bf190bc6e9db9
+  data.tar.gz: 34d811c5ab6afb7d5b4b9dc871b2df660f42abaf146ffc7faa60c9d4d2edfb8c1a8fa6e49b40488a6090a7bb64218fafb6b0e965744b4daa0d11c0fc34605abf

data/History.rdoc

@@ -1,3 +1,26 @@
+== 12.0.9 (2021-02-22)
+* Third time is hopefully the charm on MySQL/MariaDB auto increment fix
+
+== 12.0.8 (2021-02-16)
+* Revert to previous MySQL/MariaDB auto increment fix
+
+== 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)

data/lib/composite_primary_keys.rb

@@ -99,7 +99,6 @@ 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'
 

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

@@ -5,16 +5,31 @@ module ActiveRecord
         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
-          id_value || pk.map {|key| value.first[key]}
+          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)
+          # 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/sqlserver/database_statements.rb

@@ -15,15 +15,18 @@ module ActiveRecord
 
                   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} #{id_sql_type});
-                      # CPK
-                      # #{sql.dup.insert sql.index(/ (DEFAULT )?VALUES/), " OUTPUT INSERTED.#{quoted_pk} INTO @ssaIdInsertTable"}
+                      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 CAST(#{quoted_pk.join(',')} AS #{id_sql_type}) FROM @ssaIdInsertTable
+                      SELECT #{quoted_pk.map {|subkey| "CAST(#{subkey} AS #{id_sql_type}) #{subkey}"}.join(", ")} FROM @ssaIdInsertTable
                     SQL
                   else
                     # CPK

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

@@ -4,7 +4,7 @@ module CompositePrimaryKeys
       def in_batches(of: 1000, start: nil, finish: nil, load: false, error_on_ignore: nil)
         relation = self
         unless block_given?
-          return BatchEnumerator.new(of: of, start: start, finish: finish, relation: self)
+          return ::ActiveRecord::Batches::BatchEnumerator.new(of: of, start: start, finish: finish, relation: self)
         end
 
         if arel.orders.present?

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  = 9
     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/connections/databases.ci.yml

@@ -1,7 +1,9 @@
 mysql:
   adapter: mysql2
-  username: travis
-  password: ""
+  username: github
+  password: github
+  host: 127.0.0.1
+  port: 3306
   encoding: utf8mb4
   charset: utf8mb4
   collation: utf8mb4_bin
@@ -11,6 +13,7 @@ postgresql:
   adapter: postgresql
   database: composite_primary_keys_unittest
   username: postgres
+  password: postgres
   host: localhost
 
 sqlite:

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_create.rb

@@ -48,12 +48,21 @@ class TestCreate < ActiveSupport::TestCase
     end
   end
 
+  def test_create_with_array
+    date = Date.new(2027, 01, 27)
+    tariff = Tariff.create!(id: [10, date], amount: 27)
+    refute_nil(tariff)
+    assert_equal([10, date], tariff.id)
+    assert_equal(date, tariff.start_date)
+    assert_equal(27, tariff.amount)
+  end
+
   def test_create_with_partial_serial
     attributes = {:location_id => 100}
 
     # SQLite does not support an autoincrementing field in a composite key
     if Department.connection.class.name == "ActiveRecord::ConnectionAdapters::SQLite3Adapter"
-      attributes[:id] = 100
+      attributes[:id] = 200
     end
 
     department = Department.new(attributes)
@@ -177,4 +186,21 @@ class TestCreate < ActiveSupport::TestCase
     suburb = Suburb.find_or_create_by!(:name => 'New Suburb', :city_id => 3, :suburb_id => 1)
     refute_nil(suburb)
   end
+
+  def test_cache
+    Suburb.cache do
+      # Suburb does not exist
+      suburb = Suburb.find_by(:city_id => 10, :suburb_id => 10)
+      assert_nil(suburb)
+
+      # Create it
+      suburb = Suburb.create!(:name => 'New Suburb', :city_id => 10, :suburb_id => 10)
+
+      # Should be able to find it
+      suburb = Suburb.find_by(:city_id => 10)
+      refute_nil(suburb)
+      refute_nil(suburb.city_id)
+      refute_nil(suburb.suburb_id)
+    end
+  end
 end

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)
@@ -91,6 +103,13 @@ class TestFind < ActiveSupport::TestCase
     end
   end
 
+  def test_in_batches_enumerator
+    enumerator = Department.in_batches
+    enumerator.each do |batch|
+      assert_equal(Department.count, batch.size)
+    end
+  end
+
   def test_in_batches_of_1
     num_found = 0
     Department.in_batches(of: 1) do |batch|

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.9
 platform: ruby
 authors:
 - Charlie Savage
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-11-12 00:00:00.000000000 Z
+date: 2021-02-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -39,7 +39,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 description: Composite key support for ActiveRecord
-email: 
+email:
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -71,7 +71,6 @@ files:
 - lib/composite_primary_keys/composite_relation.rb
 - lib/composite_primary_keys/connection_adapters/abstract/database_statements.rb
 - lib/composite_primary_keys/connection_adapters/abstract_adapter.rb
-- lib/composite_primary_keys/connection_adapters/mysql/database_statements.rb
 - lib/composite_primary_keys/connection_adapters/postgresql/database_statements.rb
 - lib/composite_primary_keys/connection_adapters/sqlserver/database_statements.rb
 - lib/composite_primary_keys/core.rb
@@ -201,7 +200,7 @@ homepage: https://github.com/composite-primary-keys/composite_primary_keys
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -216,16 +215,16 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.4
-signing_key: 
+rubygems_version: 3.2.8
+signing_key:
 specification_version: 4
 summary: Composite key support for ActiveRecord
 test_files:
-- test/abstract_unit.rb
 - test/README_tests.rdoc
+- test/abstract_unit.rb
 - test/test_associations.rb
-- test/test_attributes.rb
 - test/test_attribute_methods.rb
+- test/test_attributes.rb
 - test/test_calculations.rb
 - test/test_callbacks.rb
 - test/test_composite_arrays.rb

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

@@ -1,24 +0,0 @@
-# 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