composite_primary_keys 12.0.9 → 13.0.2

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

@@ -1,44 +1,44 @@
-module ActiveRecord
-  module ConnectionAdapters
-    module SQLServer
-      module DatabaseStatements
-        def sql_for_insert(sql, pk, binds)
-          if pk.nil?
-            table_name = query_requires_identity_insert?(sql)
-            pk = primary_key(table_name)
-          end
-
-          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
-  end
-end
+module ActiveRecord
+  module ConnectionAdapters
+    module SQLServer
+      module DatabaseStatements
+        def sql_for_insert(sql, pk, binds)
+          if pk.nil?
+            table_name = query_requires_identity_insert?(sql)
+            pk = primary_key(table_name)
+          end
+
+          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
+  end
+end

data/lib/composite_primary_keys/core.rb

@@ -1,49 +1,49 @@
-module ActiveRecord
-  module Core
-    def initialize_dup(other) # :nodoc:
-      @attributes = @attributes.deep_dup
-      # CPK
-      #@attributes.reset(@primary_key)
-      Array(self.class.primary_key).each {|key| @attributes.reset(key)}
-
-      _run_initialize_callbacks
-
-      @new_record               = true
-      @destroyed                = false
-      @_start_transaction_state = nil
-      @transaction_state        = nil
-
-      super
-    end
-
-    module ClassMethods
-      def find(*ids) # :nodoc:
-        # We don't have cache keys for this stuff yet
-        return super unless ids.length == 1
-        return super if block_given? ||
-            primary_key.nil? ||
-            scope_attributes? ||
-            columns_hash.key?(inheritance_column) && !base_class?
-
-        # CPK
-        return super if self.composite?
-
-        id = ids.first
-
-        return super if StatementCache.unsupported_value?(id)
-
-        key = primary_key
-
-        statement = cached_find_by_statement(key) { |params|
-          where(key => params.bind).limit(1)
-        }
-
-        record = statement.execute([id], connection)&.first
-        unless record
-          raise ::ActiveRecord::RecordNotFound.new("Couldn't find #{name} with '#{key}'=#{id}", name, key, id)
-        end
-        record
-      end
-    end
-  end
+module ActiveRecord
+  module Core
+    def initialize_dup(other) # :nodoc:
+      @attributes = @attributes.deep_dup
+      # CPK
+      #@attributes.reset(@primary_key)
+      Array(self.class.primary_key).each {|key| @attributes.reset(key)}
+
+      _run_initialize_callbacks
+
+      @new_record               = true
+      @destroyed                = false
+      @_start_transaction_state = nil
+      @transaction_state        = nil
+
+      super
+    end
+
+    module ClassMethods
+      def find(*ids) # :nodoc:
+        # We don't have cache keys for this stuff yet
+        return super unless ids.length == 1
+        return super if block_given? ||
+            primary_key.nil? ||
+            scope_attributes? ||
+            columns_hash.key?(inheritance_column) && !base_class?
+
+        # CPK
+        return super if self.composite?
+
+        id = ids.first
+
+        return super if StatementCache.unsupported_value?(id)
+
+        key = primary_key
+
+        statement = cached_find_by_statement(key) { |params|
+          where(key => params.bind).limit(1)
+        }
+
+        record = statement.execute([id], connection)&.first
+        unless record
+          raise ::ActiveRecord::RecordNotFound.new("Couldn't find #{name} with '#{key}'=#{id}", name, key, id)
+        end
+        record
+      end
+    end
+  end
 end

data/lib/composite_primary_keys/counter_cache.rb

@@ -1,15 +1,15 @@
-module ActiveRecord
-  module CounterCache
-    module ClassMethods
-      def update_counters(id, counters)
-        # CPK
-        if self.composite?
-          predicate = cpk_id_predicate(self.arel_table, primary_key, id)
-          unscoped.where!(predicate).update_counters(counters)
-        else
-          unscoped.where!(primary_key => id).update_counters(counters)
-        end
-      end
-    end
-  end
-end
+module ActiveRecord
+  module CounterCache
+    module ClassMethods
+      def update_counters(id, counters)
+        # CPK
+        if self.composite?
+          predicate = cpk_id_predicate(self.arel_table, primary_key, id)
+          unscoped.where!(predicate).update_counters(counters)
+        else
+          unscoped.where!(primary_key => id).update_counters(counters)
+        end
+      end
+    end
+  end
+end

data/lib/composite_primary_keys/fixtures.rb

@@ -1,21 +1,21 @@
-module ActiveRecord
-  class Fixture
-    def find
-      raise FixtureClassNotFound, "No class attached to find." unless model_class
-      model_class.unscoped do
-        # CPK
-        #model_class.find(fixture[model_class.primary_key])
-        ids = self.ids(model_class.primary_key)
-        model_class.find(ids)
-      end
-    end
-
-    def ids(key)
-      if key.is_a? Array
-        key.map {|a_key| fixture[a_key.to_s] }
-      else
-        fixture[key]
-      end
-    end
-  end
-end
+module ActiveRecord
+  class Fixture
+    def find
+      raise FixtureClassNotFound, "No class attached to find." unless model_class
+      model_class.unscoped do
+        # CPK
+        #model_class.find(fixture[model_class.primary_key])
+        ids = self.ids(model_class.primary_key)
+        model_class.find(ids)
+      end
+    end
+
+    def ids(key)
+      if key.is_a? Array
+        key.map {|a_key| fixture[a_key.to_s] }
+      else
+        fixture[key]
+      end
+    end
+  end
+end

data/lib/composite_primary_keys/nested_attributes.rb

@@ -70,7 +70,7 @@ module ActiveRecord
             if target_record
               existing_record = target_record
             else
-              association.add_to_target(existing_record, :skip_callbacks)
+              association.add_to_target(existing_record, skip_callbacks: true)
             end
 
             assign_to_or_mark_for_destruction(existing_record, attributes, options[:allow_destroy])

data/lib/composite_primary_keys/persistence.rb

@@ -10,11 +10,12 @@ module ActiveRecord
                           Array(id_or_array)
                         end
 
-          id_or_array.each do |id|
+          # Delete should return the number of deleted records
+          id_or_array.map do |id|
             # Is the passed in id actually a record?
             id = id.kind_of?(::ActiveRecord::Base) ? id.id : id
             delete_by(cpk_id_predicate(self.arel_table, self.primary_key, id))
-          end
+          end.sum
         else
           delete_by(primary_key => id_or_array)
         end

data/lib/composite_primary_keys/reflection.rb

@@ -1,29 +1,91 @@
-module ActiveRecord
-  module Reflection
-    class AbstractReflection
-      def join_scope(table, foreign_table, foreign_klass)
-        predicate_builder = predicate_builder(table)
-        scope_chain_items = join_scopes(table, predicate_builder)
-        klass_scope       = klass_join_scope(table, predicate_builder)
-
-        key         = join_keys.key
-        foreign_key = join_keys.foreign_key
-
-        # CPK
-        #klass_scope.where!(table[key].eq(foreign_table[foreign_key]))
-        constraint = cpk_join_predicate(table, key, foreign_table, foreign_key)
-        klass_scope.where!(constraint)
-
-        if type
-          klass_scope.where!(type => foreign_klass.polymorphic_name)
-        end
-
-        if klass.finder_needs_type_condition?
-          klass_scope.where!(klass.send(:type_condition, table))
-        end
-
-        scope_chain_items.inject(klass_scope, &:merge!)
-      end
-    end
-  end
-end
+module ActiveRecord
+  module Reflection
+    class AbstractReflection
+      def join_scope(table, foreign_table, foreign_klass)
+        predicate_builder = predicate_builder(table)
+        scope_chain_items = join_scopes(table, predicate_builder)
+        klass_scope       = klass_join_scope(table, predicate_builder)
+
+        key         = join_primary_key
+        foreign_key = join_foreign_key
+
+        # CPK
+        #klass_scope.where!(table[key].eq(foreign_table[foreign_key]))
+        constraint = cpk_join_predicate(table, key, foreign_table, foreign_key)
+        klass_scope.where!(constraint)
+
+        if type
+          klass_scope.where!(type => foreign_klass.polymorphic_name)
+        end
+
+        if klass.finder_needs_type_condition?
+          klass_scope.where!(klass.send(:type_condition, table))
+        end
+
+        scope_chain_items.inject(klass_scope, &:merge!)
+      end
+    end
+
+    class AssociationReflection < MacroReflection
+      def foreign_key
+        # CPK
+        # @foreign_key ||= -(options[:foreign_key]&.to_s || derive_foreign_key)
+        @foreign_key ||= extract_keys(options[:foreign_key]) || derive_foreign_key
+      end
+
+      def association_foreign_key
+        # CPK
+        # @association_foreign_key ||= -(options[:association_foreign_key]&.to_s || class_name.foreign_key)
+        @association_foreign_key ||= extract_keys(options[:association_foreign_key]) || class_name.foreign_key
+      end
+
+      def active_record_primary_key
+        # CPK (Rails freezes the string returned in the expression that calculates PK here. But Rails uses the `-` method which is not available on Array for CPK, so we calculate it in one line and freeze it on the next)
+        # @active_record_primary_key ||= -(options[:primary_key]&.to_s || primary_key(active_record))
+        @active_record_primary_key ||= begin
+          pk = options[:primary_key] || primary_key(active_record)
+          pk.freeze
+        end
+      end
+
+      private
+
+      def extract_keys(keys)
+        case keys
+          when Array
+            keys.map { |k| k.to_s }
+          when NilClass
+            nil
+          else
+            keys.to_s
+        end
+      end
+    end
+
+    class BelongsToReflection < AssociationReflection
+      def association_primary_key(klass = nil)
+        if primary_key = options[:primary_key]
+          # CPK
+          # @association_primary_key ||= -primary_key.to_s
+          @association_primary_key ||= primary_key.freeze
+        else
+          primary_key(klass || self.klass)
+        end
+      end
+    end
+
+    class ThroughReflection < AbstractReflection #:nodoc:
+      def association_primary_key(klass = nil)
+        # Get the "actual" source reflection if the immediate source reflection has a
+        # source reflection itself
+        if primary_key = actual_source_reflection.options[:primary_key]
+          # CPK
+          # @association_primary_key ||= -primary_key.to_s
+          @association_primary_key ||= primary_key.freeze
+        else
+          primary_key(klass || self.klass)
+        end
+      end
+    end
+  end
+end

data/lib/composite_primary_keys/relation/batches.rb

@@ -1,12 +1,16 @@
 module CompositePrimaryKeys
   module ActiveRecord
     module Batches
-      def in_batches(of: 1000, start: nil, finish: nil, load: false, error_on_ignore: nil)
+      def in_batches(of: 1000, start: nil, finish: nil, load: false, error_on_ignore: nil, order: :asc)
         relation = self
         unless block_given?
           return ::ActiveRecord::Batches::BatchEnumerator.new(of: of, start: start, finish: finish, relation: self)
         end
 
+        unless [:asc, :desc].include?(order)
+          raise ArgumentError, ":order must be :asc or :desc, got #{order.inspect}"
+        end
+
         if arel.orders.present?
           act_on_ignored_order(error_on_ignore)
         end
@@ -17,8 +21,8 @@ module CompositePrimaryKeys
           batch_limit = remaining if remaining < batch_limit
         end
 
-        relation = relation.reorder(batch_order).limit(batch_limit)
-        relation = apply_limits(relation, start, finish)
+        relation = relation.reorder(batch_order(order)).limit(batch_limit)
+        relation = apply_limits(relation, start, finish, order)
         relation.skip_query_cache! # Retaining the results in the query cache would undermine the point of batching
         batch_relation = relation
 
@@ -61,7 +65,9 @@ module CompositePrimaryKeys
           end
 
           # CPK
-          # batch_relation = relation.where(arel_attribute(primary_key).gt(primary_key_offset))
+          #batch_relation = relation.where(
+          #  predicate_builder[primary_key, primary_key_offset, order == :desc ? :lt : :gt]
+          #)
           batch_relation = if composite?
             # CPK
             # Lexicographically select records
@@ -81,7 +87,9 @@ module CompositePrimaryKeys
             end.reduce(:or)
             relation.where(query)
           else
-            relation.where(arel_attribute(primary_key).gt(primary_key_offset))
+            batch_relation = relation.where(
+              predicate_builder[primary_key, primary_key_offset, order == :desc ? :lt : :gt]
+            )
           end
         end
       end
@@ -95,9 +103,9 @@ module CompositePrimaryKeys
         ary.length.times.reduce([]) { |results, i| results << ary[0..i] }
       end
 
-      def batch_order
+      def batch_order(order)
         self.primary_key.map do |key|
-          arel_attribute(key).asc
+          table[key].public_send(order)
         end
       end
     end

data/lib/composite_primary_keys/relation/calculations.rb

@@ -4,11 +4,12 @@ module CompositePrimaryKeys
       def aggregate_column(column_name)
         # CPK
         if column_name.kind_of?(Array)
+          # Note: Test don't seem to run this code?
           column_name.map do |column|
-            @klass.arel_attribute(column_name)
+            @klass.arel_table[column]
           end
         elsif @klass.has_attribute?(column_name) || @klass.attribute_alias?(column_name)
-          @klass.arel_attribute(column_name)
+          @klass.arel_table[column_name]
         else
           Arel.sql(column_name == :all ? "*" : column_name.to_s)
         end
@@ -31,38 +32,33 @@ module CompositePrimaryKeys
           relation = unscope(:order).distinct!(false)
 
           column = aggregate_column(column_name)
-
           select_value = operation_over_aggregate_column(column, operation, distinct)
-          if operation == "sum" && distinct
-            select_value.distinct = true
-          end
+          select_value.distinct = true if operation == "sum" && distinct
 
-          column_alias = select_value.alias
-          column_alias ||= @klass.connection.column_name_for_operation(operation, select_value)
           relation.select_values = [select_value]
 
           query_builder = relation.arel
         end
 
-        result = skip_query_cache_if_necessary { @klass.connection.select_all(query_builder, nil) }
-        row    = result.first
-        value  = row && row.values.first
-        type   = result.column_types.fetch(column_alias) do
-          type_for(column_name)
-        end
+        result = skip_query_cache_if_necessary { @klass.connection.select_all(query_builder) }
 
-        type_cast_calculated_value(value, type, operation)
+        type_cast_calculated_value(result.cast_values.first, operation) do |value|
+          type = column.try(:type_caster) ||
+            # CPK
+            # lookup_cast_type_from_join_dependencies(column_name.to_s) || Type.default_value
+            lookup_cast_type_from_join_dependencies(column_name.to_s) || ::ActiveRecord::Type.default_value
+          type.deserialize(value)
+        end
       end
 
       def build_count_subquery(relation, column_name, distinct)
         if column_name == :all
+          column_alias = Arel.star
+          # CPK
+          # relation.select_values = [ Arel.sql(FinderMethods::ONE_AS_ONE) ] unless distinct
           relation.select_values = [ Arel.sql(::ActiveRecord::FinderMethods::ONE_AS_ONE) ] unless distinct
-          if relation.select_values.first.is_a?(Array)
-            relation.select_values = relation.select_values.first.map do |column|
-              Arel::Attribute.new(@klass.unscoped.table, column)
-            end
-          end
         elsif column_name.is_a?(Array)
+          column_alias = Arel.star
           relation.select_values = column_name.map do |column|
             Arel::Attribute.new(@klass.unscoped.table, column)
           end
@@ -71,10 +67,37 @@ module CompositePrimaryKeys
           relation.select_values = [ aggregate_column(column_name).as(column_alias) ]
         end
 
-        subquery = relation.arel.as(Arel.sql("subquery_for_count"))
-        select_value = operation_over_aggregate_column(column_alias || Arel.star, "count", false)
+        subquery_alias = Arel.sql("subquery_for_count")
+        select_value = operation_over_aggregate_column(column_alias, "count", false)
+
+        relation.build_subquery(subquery_alias, select_value)
+      end
+
+      def calculate(operation, column_name)
+        if has_include?(column_name)
+          relation = apply_join_dependency
 
-        Arel::SelectManager.new(subquery).project(select_value)
+          if operation.to_s.downcase == "count"
+            unless distinct_value || distinct_select?(column_name || select_for_count)
+              relation.distinct!
+              # CPK
+              # relation.select_values = [ klass.primary_key || table[Arel.star] ]
+              if klass.primary_key.present? && klass.primary_key.is_a?(Array)
+                relation.select_values = klass.primary_key.map do |k|
+                  "#{connection.quote_table_name(klass.table_name)}.#{connection.quote_column_name(k)}"
+                end
+              else
+                relation.select_values = [ klass.primary_key || table[Arel.star] ]
+              end
+            end
+            # PostgreSQL: ORDER BY expressions must appear in SELECT list when using DISTINCT
+            relation.order_values = [] if group_values.empty?
+          end
+
+          relation.calculate(operation, column_name)
+        else
+          perform_calculation(operation, column_name)
+        end
       end
     end
   end