composite_primary_keys 14.0.5 → 14.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4feff3a4f8ce272695c7a081666b99f3e9b79b206dce5acf9728c0c2c0cb2d9a
-  data.tar.gz: f5d7533a624427d056ad9fd7576242a2b6318ed584939bea834de44bd8d618af
+  metadata.gz: 76a010358e1d2cacd9b05f6229c1fe4225f20f888fefb57b0bd6a9f62589a720
+  data.tar.gz: 1b7870c774bbed21d4556cf53518054860903cae4a0987f5978e02fc3883597f
 SHA512:
-  metadata.gz: a2e52091afe3577f46df1e0093ad6d4d6167a250e27ec7776af7706b8ec01fce0539f15a0bcaa1d12273ac2ed8055cddcc6fef5536b5e7ae8761d4158c2f9a6a
-  data.tar.gz: 8159181dd45c05ba6aad2a57ff482bdf8471904d6990517e04a992bc177e42b5cb201dfb48ff7e645ecfb2e23270ed129a9a6666b87a6412d07a3163200e4d72
+  metadata.gz: 117d7be0b54619f7adcb05ddb200c3c97571cc74bf2fcf33c99034efaec08924cf6d56e998db1135c92bf71497697b30ca531a882d755329d5b6f9192d606013
+  data.tar.gz: a9f330398e5b1a9153a67f229a28e83d65c5bc02334e6e9f3456229c4c1e011a3bf03909fa45e37739d4ab47a37663a3ee6ef09c7d7194721e91849e520c0a01

data/History.rdoc

@@ -1,3 +1,7 @@
+== 14.0.6 (2023-02-04)
+* Port fix for #573 (Charlie Savage)
+* Port fix for fix #577 (Charlie Savage)
+
 == 14.0.5 (2023-02-04)
 * Improve query generation for cpk_in_predicate. This reduces the length of
 queries when loading many keys and enables Postgres to use index scans
@@ -27,6 +31,17 @@ more frequently. (Andrew Kiellor)
 == 14.0.0 (2022-01-9)
 * Update to ActiveRecord 7.0 (Sammy Larbi)
 
+== 13.0.7 (2023-02-04)
+* Fix #573 (Charlie Savage)
+
+== 13.0.6 (2023-02-04)
+* Fix #577 (Charlie Savage)
+
+== 13.0.5 (2023-02-04)
+* Improve query generation for cpk_in_predicate. This reduces the length of
+queries when loading many keys and enables Postgres to use index scans
+more frequently. (Andrew Kiellor)
+
 == 13.0.4 (2022-12-05)
 * Fix previously_new_record? not being set to true after create (Akinori MUSHA)
 

data/lib/composite_primary_keys/associations/preloader/association.rb

@@ -46,22 +46,6 @@ module ActiveRecord
             (result[key] ||= []) << owner if key
           end
         end
-
-        # TODO: is records_by_owner needed anymore? Rails' implementation has changed significantly
-        def records_by_owner
-          @records_by_owner ||= preloaded_records.each_with_object({}) do |record, result|
-            key = if association_key_name.is_a?(Array)
-                    Array(record[association_key_name]).map do |key|
-                      convert_key(key)
-                    end
-                  else
-                    convert_key(record[association_key_name])
-                  end
-            owners_by_key[key].each do |owner|
-              (result[owner] ||= []) << record
-            end
-          end
-        end
       end
     end
   end

data/lib/composite_primary_keys/relation.rb

@@ -1,197 +1,197 @@
-module ActiveRecord
-  class Relation
-    alias :initialize_without_cpk :initialize
-    def initialize(klass, table: klass.arel_table, predicate_builder: klass.predicate_builder, values: {})
-      initialize_without_cpk(klass, table: table, predicate_builder: predicate_builder, values: values)
-      add_cpk_support if klass && klass.composite?
-    end
-
-    alias :initialize_copy_without_cpk :initialize_copy
-    def initialize_copy(other)
-      initialize_copy_without_cpk(other)
-      add_cpk_support if klass.composite?
-    end
-
-    def add_cpk_support
-      extend CompositePrimaryKeys::CompositeRelation
-    end
-
-    def update_all(updates)
-      raise ArgumentError, "Empty list of attributes to change" if updates.blank?
-
-      if eager_loading?
-        relation = apply_join_dependency
-        return relation.update_all(updates)
-      end
-
-      stmt = Arel::UpdateManager.new
-      stmt.table(arel.join_sources.empty? ? table : arel.source)
-      stmt.key = table[primary_key]
-
-      # CPK
-      if @klass.composite? && @klass.connection.visitor.compile(stmt.ast) =~ /['"]#{primary_key.to_s}['"]/
-        stmt = Arel::UpdateManager.new
-        stmt.table(arel_table)
-        cpk_subquery(stmt)
-      else
-        stmt.wheres = arel.constraints
-      end
-      stmt.take(arel.limit)
-      stmt.offset(arel.offset)
-      stmt.order(*arel.orders)
-
-      if updates.is_a?(Hash)
-        if klass.locking_enabled? &&
-            !updates.key?(klass.locking_column) &&
-            !updates.key?(klass.locking_column.to_sym)
-          attr = table[klass.locking_column]
-          updates[attr.name] = _increment_attribute(attr)
-        end
-        stmt.set _substitute_values(updates)
-      else
-        stmt.set Arel.sql(klass.sanitize_sql_for_assignment(updates, table.name))
-      end
-
-      @klass.connection.update stmt, "#{@klass} Update All"
-    end
-
-    def delete_all
-      invalid_methods = INVALID_METHODS_FOR_DELETE_ALL.select do |method|
-        value = @values[method]
-        method == :distinct ? value : value&.any?
-      end
-      if invalid_methods.any?
-        raise ActiveRecordError.new("delete_all doesn't support #{invalid_methods.join(', ')}")
-      end
-
-      if eager_loading?
-        relation = apply_join_dependency
-        return relation.delete_all
-      end
-
-      stmt = Arel::DeleteManager.new
-      stmt.from(arel.join_sources.empty? ? table : arel.source)
-      stmt.key = table[primary_key]
-
-      # CPK
-      if @klass.composite? && @klass.connection.visitor.compile(stmt.ast) =~ /['"]#{primary_key.to_s}['"]/
-        stmt = Arel::DeleteManager.new
-        stmt.from(arel_table)
-        cpk_subquery(stmt)
-      else
-        stmt.wheres = arel.constraints
-      end
-
-      stmt.take(arel.limit)
-      stmt.offset(arel.offset)
-      stmt.order(*arel.orders)
-
-      affected = @klass.connection.delete(stmt, "#{@klass} Destroy")
-
-      reset
-      affected
-    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
-      subquery.projections = primary_keys.map do |key|
-        arel_table[key]
-      end
-
-      where_fields = primary_keys.map do |key|
-        arel_table[key]
-      end
-      where = Arel::Nodes::Grouping.new(where_fields).in(subquery)
-      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)
-      arel_attributes = primary_keys.map do |key|
-        table[key]
-      end.to_composite_keys
-
-      # 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 = arel_table[key]
-        inner_attribute = aliased_table[key]
-        where = outer_attribute.eq(inner_attribute)
-        subselect.where(where)
-      end
-      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|
-        table[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
+module ActiveRecord
+  class Relation
+    alias :initialize_without_cpk :initialize
+    def initialize(klass, table: klass.arel_table, predicate_builder: klass.predicate_builder, values: {})
+      initialize_without_cpk(klass, table: table, predicate_builder: predicate_builder, values: values)
+      add_cpk_support if klass && klass.composite?
+    end
+
+    alias :initialize_copy_without_cpk :initialize_copy
+    def initialize_copy(other)
+      initialize_copy_without_cpk(other)
+      add_cpk_support if klass.composite?
+    end
+
+    def add_cpk_support
+      extend CompositePrimaryKeys::CompositeRelation
+    end
+
+    def update_all(updates)
+      raise ArgumentError, "Empty list of attributes to change" if updates.blank?
+
+      if eager_loading?
+        relation = apply_join_dependency
+        return relation.update_all(updates)
+      end
+
+      stmt = Arel::UpdateManager.new
+      stmt.table(arel.join_sources.empty? ? table : arel.source)
+      stmt.key = table[primary_key]
+
+      # CPK
+      if @klass.composite?
+        stmt = Arel::UpdateManager.new
+        stmt.table(arel_table)
+        cpk_subquery(stmt)
+      else
+        stmt.wheres = arel.constraints
+      end
+      stmt.take(arel.limit)
+      stmt.offset(arel.offset)
+      stmt.order(*arel.orders)
+
+      if updates.is_a?(Hash)
+        if klass.locking_enabled? &&
+            !updates.key?(klass.locking_column) &&
+            !updates.key?(klass.locking_column.to_sym)
+          attr = table[klass.locking_column]
+          updates[attr.name] = _increment_attribute(attr)
+        end
+        stmt.set _substitute_values(updates)
+      else
+        stmt.set Arel.sql(klass.sanitize_sql_for_assignment(updates, table.name))
+      end
+
+      @klass.connection.update stmt, "#{@klass} Update All"
+    end
+
+    def delete_all
+      invalid_methods = INVALID_METHODS_FOR_DELETE_ALL.select do |method|
+        value = @values[method]
+        method == :distinct ? value : value&.any?
+      end
+      if invalid_methods.any?
+        raise ActiveRecordError.new("delete_all doesn't support #{invalid_methods.join(', ')}")
+      end
+
+      if eager_loading?
+        relation = apply_join_dependency
+        return relation.delete_all
+      end
+
+      stmt = Arel::DeleteManager.new
+      stmt.from(arel.join_sources.empty? ? table : arel.source)
+      stmt.key = table[primary_key]
+
+      # CPK
+      if @klass.composite?
+        stmt = Arel::DeleteManager.new
+        stmt.from(arel_table)
+        cpk_subquery(stmt)
+      else
+        stmt.wheres = arel.constraints
+      end
+
+      stmt.take(arel.limit)
+      stmt.offset(arel.offset)
+      stmt.order(*arel.orders)
+
+      affected = @klass.connection.delete(stmt, "#{@klass} Destroy")
+
+      reset
+      affected
+    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
+      subquery.projections = primary_keys.map do |key|
+        arel_table[key]
+      end
+
+      where_fields = primary_keys.map do |key|
+        arel_table[key]
+      end
+      where = Arel::Nodes::Grouping.new(where_fields).in(subquery)
+      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)
+      arel_attributes = primary_keys.map do |key|
+        table[key]
+      end.to_composite_keys
+
+      # 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 = arel_table[key]
+        inner_attribute = aliased_table[key]
+        where = outer_attribute.eq(inner_attribute)
+        subselect.where(where)
+      end
+      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|
+        table[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/version.rb

@@ -2,7 +2,7 @@ module CompositePrimaryKeys
   module VERSION
     MAJOR = 14
     MINOR = 0
-    TINY  = 5
+    TINY  = 6
     STRING = [MAJOR, MINOR, TINY].join('.')
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: composite_primary_keys
 version: !ruby/object:Gem::Version
-  version: 14.0.5
+  version: 14.0.6
 platform: ruby
 authors:
 - Charlie Savage