composite_primary_keys 12.0.9 → 13.0.0

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

@@ -1,81 +1,104 @@
-module CompositePrimaryKeys
-  module ActiveRecord
-    module Calculations
-      def aggregate_column(column_name)
-        # CPK
-        if column_name.kind_of?(Array)
-          column_name.map do |column|
-            @klass.arel_attribute(column_name)
-          end
-        elsif @klass.has_attribute?(column_name) || @klass.attribute_alias?(column_name)
-          @klass.arel_attribute(column_name)
-        else
-          Arel.sql(column_name == :all ? "*" : column_name.to_s)
-        end
-      end
-
-      def execute_simple_calculation(operation, column_name, distinct) #:nodoc:
-        column_alias = column_name
-
-        # CPK
-        # if operation == "count" && (column_name == :all && distinct || has_limit_or_offset?)
-        #   # Shortcut when limit is zero.
-        #   return 0 if limit_value == 0
-        #
-        #   query_builder = build_count_subquery(spawn, column_name, distinct)
-        if operation == "count"
-          relation = unscope(:order)
-          query_builder = build_count_subquery(spawn, column_name, distinct)
-        else
-          # PostgreSQL doesn't like ORDER BY when there are no GROUP BY
-          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
-
-          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
-
-        type_cast_calculated_value(value, type, operation)
-      end
-
-      def build_count_subquery(relation, column_name, distinct)
-        if column_name == :all
-          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)
-          relation.select_values = column_name.map do |column|
-            Arel::Attribute.new(@klass.unscoped.table, column)
-          end
-        else
-          column_alias = Arel.sql("count_column")
-          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)
-
-        Arel::SelectManager.new(subquery).project(select_value)
-      end
-    end
-  end
-end
+module CompositePrimaryKeys
+  module ActiveRecord
+    module Calculations
+      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_table[column]
+          end
+        elsif @klass.has_attribute?(column_name) || @klass.attribute_alias?(column_name)
+          @klass.arel_table[column_name]
+        else
+          Arel.sql(column_name == :all ? "*" : column_name.to_s)
+        end
+      end
+
+      def execute_simple_calculation(operation, column_name, distinct) #:nodoc:
+        column_alias = column_name
+
+        # CPK
+        # if operation == "count" && (column_name == :all && distinct || has_limit_or_offset?)
+        #   # Shortcut when limit is zero.
+        #   return 0 if limit_value == 0
+        #
+        #   query_builder = build_count_subquery(spawn, column_name, distinct)
+        if operation == "count"
+          relation = unscope(:order)
+          query_builder = build_count_subquery(spawn, column_name, distinct)
+        else
+          # PostgreSQL doesn't like ORDER BY when there are no GROUP BY
+          relation = unscope(:order).distinct!(false)
+
+          column = aggregate_column(column_name)
+          select_value = operation_over_aggregate_column(column, operation, distinct)
+          select_value.distinct = true if operation == "sum" && distinct
+
+          relation.select_values = [select_value]
+
+          query_builder = relation.arel
+        end
+
+        result = skip_query_cache_if_necessary { @klass.connection.select_all(query_builder) }
+
+        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
+        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
+        else
+          column_alias = Arel.sql("count_column")
+          relation.select_values = [ aggregate_column(column_name).as(column_alias) ]
+        end
+
+        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
+
+          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
+end

data/lib/composite_primary_keys/relation/finder_methods.rb

@@ -1,235 +1,235 @@
-module CompositePrimaryKeys
-  module ActiveRecord
-    module FinderMethods
-      def apply_join_dependency(eager_loading: group_values.empty?)
-        join_dependency = construct_join_dependency(eager_load_values + includes_values, Arel::Nodes::OuterJoin)
-        relation = except(:includes, :eager_load, :preload).joins!(join_dependency)
-
-        if eager_loading && !using_limitable_reflections?(join_dependency.reflections)
-          if has_limit_or_offset?
-            limited_ids = limited_ids_for(relation)
-
-            # CPK
-            # limited_ids.empty? ? relation.none! : relation.where!(primary_key => limited_ids)
-            limited_ids.empty? ? relation.none! : relation.where!(cpk_in_predicate(table, self.primary_keys, limited_ids))
-          end
-          relation.limit_value = relation.offset_value = nil
-        end
-
-        if block_given?
-          yield relation, join_dependency
-        else
-          relation
-        end
-      end
-
-      def limited_ids_for(relation)
-        # CPK
-        # values = @klass.connection.columns_for_distinct(
-        #     connection.column_name_from_arel_node(arel_attribute(primary_key)),
-        #     relation.order_values
-        # )
-
-        columns = @klass.primary_keys.map do |key|
-          connection.visitor.compile(arel_attribute(key))
-        end
-        values = @klass.connection.columns_for_distinct(columns, relation.order_values)
-
-        relation = relation.except(:select).select(values).distinct!
-
-        id_rows = skip_query_cache_if_necessary { @klass.connection.select_all(relation.arel, "SQL") }
-        # CPK
-        #id_rows.map { |row| row[primary_key] }
-        id_rows.map do |row|
-          @klass.primary_keys.map do |key|
-            row[key]
-          end
-        end
-      end
-
-      def construct_relation_for_exists(conditions)
-        conditions = sanitize_forbidden_attributes(conditions)
-
-        if distinct_value && offset_value
-          relation = except(:order).limit!(1)
-        else
-          relation = except(:select, :distinct, :order)._select!(::ActiveRecord::FinderMethods::ONE_AS_ONE).limit!(1)
-        end
-
-        case conditions
-          # CPK
-          when CompositePrimaryKeys::CompositeKeys
-            relation = relation.where(cpk_id_predicate(table, primary_key, conditions))
-          # CPK
-          when Array
-            pk_length = @klass.primary_keys.length
-
-            if conditions.length == pk_length # E.g. conditions = ['France', 'Paris']
-              return self.construct_relation_for_exists(conditions.to_composite_keys)
-            else # Assume that conditions contains where relation
-              relation = relation.where(conditions)
-            end
-          when Array, Hash
-            relation.where!(conditions) unless conditions.empty?
-          else
-            relation.where!(primary_key => conditions) unless conditions == :none
-        end
-
-        relation
-      end
-
-      def find_with_ids(*ids)
-        raise UnknownPrimaryKey.new(@klass) if primary_key.nil?
-
-        # CPK
-        # expects_array = ids.first.kind_of?(Array)
-        ids = CompositePrimaryKeys.normalize(ids, @klass.primary_keys.length)
-        expects_array = ids.flatten != ids.flatten(1)
-        return ids.first if expects_array && ids.first.empty?
-
-        # CPK
-        # ids = ids.flatten.compact.uniq
-        ids = expects_array ? ids.first : ids
-
-        model_name = @klass.name
-
-        case ids.size
-        when 0
-          error_message = "Couldn't find #{model_name} without an ID"
-          raise ::ActiveRecord::RecordNotFound.new(error_message, model_name, primary_key)
-        when 1
-          result = find_one(ids.first)
-          expects_array ? [ result ] : result
-        else
-          find_some(ids)
-        end
-      end
-
-      # def last(limit = nil)
-      #   return find_last(limit) if loaded? || has_limit_or_offset?
-      #
-      #   result = limit(limit || 1)
-      #   # CPK
-      #   # result.order!(arel_attribute(primary_key)) if order_values.empty? && primary_key
-      #   if order_values.empty? && primary_key
-      #     if composite?
-      #       result.order!(primary_keys.map { |pk| arel_attribute(pk).asc })
-      #     elsif
-      #       result.order!(arel_attribute(primary_key))
-      #     end
-      #   end
-      #
-      #   result = result.reverse_order!
-      #
-      #   limit ? result.reverse : result.first
-      # rescue ::ActiveRecord::IrreversibleOrderError
-      #   ActiveSupport::Deprecation.warn(<<-WARNING.squish)
-      #       Finding a last element by loading the relation when SQL ORDER
-      #       can not be reversed is deprecated.
-      #       Rails 5.1 will raise ActiveRecord::IrreversibleOrderError in this case.
-      #       Please call `to_a.last` if you still want to load the relation.
-      #   WARNING
-      #   find_last(limit)
-      # end
-
-      def find_one(id)
-        if ::ActiveRecord::Base === id
-          raise ArgumentError, <<-MSG.squish
-            You are passing an instance of ActiveRecord::Base to `find`.
-            Please pass the id of the object by calling `.id`.
-          MSG
-        end
-
-        # CPK
-        #relation = where(primary_key => id)
-        relation = where(cpk_id_predicate(table, primary_keys, id))
-        record = relation.take
-
-        raise_record_not_found_exception!(id, 0, 1) unless record
-
-        record
-      end
-
-      def find_some(ids)
-        # CPK
-        if composite?
-          ids = if ids.length == 1
-                  CompositePrimaryKeys::CompositeKeys.parse(ids.first)
-                else
-                  ids.to_composite_keys
-                end
-        end
-
-        return find_some_ordered(ids) unless order_values.present?
-
-        # CPK
-        # result = where(primary_key => ids).to_a
-        result = if composite?
-          result = where(cpk_in_predicate(table, primary_keys, ids)).to_a
-        else
-          result = where(primary_key => ids).to_a
-        end
-
-        expected_size =
-          if limit_value && ids.size > limit_value
-            limit_value
-          else
-            ids.size
-          end
-
-        # 11 ids with limit 3, offset 9 should give 2 results.
-        if offset_value && (ids.size - offset_value < expected_size)
-          expected_size = ids.size - offset_value
-        end
-
-        if result.size == expected_size
-          result
-        else
-          raise_record_not_found_exception!(ids, result.size, expected_size)
-        end
-      end
-
-      def find_some_ordered(ids)
-        ids = ids.slice(offset_value || 0, limit_value || ids.size) || []
-
-        # CPK
-        # result = except(:limit, :offset).where(primary_key => ids).records
-        result = if composite?
-          except(:limit, :offset).where(cpk_in_predicate(table, primary_keys, ids)).records
-        else
-          except(:limit, :offset).where(primary_key => ids).records
-        end
-
-        if result.size == ids.size
-          pk_type = @klass.type_for_attribute(primary_key)
-
-          records_by_id = result.index_by(&:id)
-          # CPK
-          # ids.map { |id| records_by_id.fetch(pk_type.cast(id)) }
-          if composite?
-            ids.map do |id|
-              typecasted_id = primary_keys.zip(id).map do |col, val|
-                @klass.type_for_attribute(col).cast(val)
-              end
-              records_by_id.fetch(typecasted_id)
-            end
-          else
-            ids.map { |id| records_by_id.fetch(pk_type.cast(id)) }
-          end
-        else
-          raise_record_not_found_exception!(ids, result.size, ids.size)
-        end
-      end
-
-      def ordered_relation
-        if order_values.empty? && (implicit_order_column || primary_key)
-          # CPK
-          # order(arel_attribute(implicit_order_column || primary_key).asc)
-          order(Array(implicit_order_column || primary_key).map {|key| arel_attribute(key).asc})
-        else
-          self
-        end
-      end
-    end
-  end
-end
+module CompositePrimaryKeys
+  module ActiveRecord
+    module FinderMethods
+      def apply_join_dependency(eager_loading: group_values.empty?)
+        join_dependency = construct_join_dependency(eager_load_values + includes_values, Arel::Nodes::OuterJoin)
+        relation = except(:includes, :eager_load, :preload).joins!(join_dependency)
+
+        if eager_loading && !using_limitable_reflections?(join_dependency.reflections)
+          if has_limit_or_offset?
+            limited_ids = limited_ids_for(relation)
+
+            # CPK
+            # limited_ids.empty? ? relation.none! : relation.where!(primary_key => limited_ids)
+            limited_ids.empty? ? relation.none! : relation.where!(cpk_in_predicate(table, self.primary_keys, limited_ids))
+          end
+          relation.limit_value = relation.offset_value = nil
+        end
+
+        if block_given?
+          yield relation, join_dependency
+        else
+          relation
+        end
+      end
+
+      def limited_ids_for(relation)
+        # CPK
+        # values = @klass.connection.columns_for_distinct(
+        #     connection.column_name_from_arel_node(table[primary_key]),
+        #     relation.order_values
+        # )
+
+        columns = @klass.primary_keys.map do |key|
+          connection.visitor.compile(table[key])
+        end
+        values = @klass.connection.columns_for_distinct(columns, relation.order_values)
+
+        relation = relation.except(:select).select(values).distinct!
+
+        id_rows = skip_query_cache_if_necessary { @klass.connection.select_all(relation.arel, "SQL") }
+        # CPK
+        #id_rows.map { |row| row[primary_key] }
+        id_rows.map do |row|
+          @klass.primary_keys.map do |key|
+            row[key]
+          end
+        end
+      end
+
+      def construct_relation_for_exists(conditions)
+        conditions = sanitize_forbidden_attributes(conditions)
+
+        if distinct_value && offset_value
+          relation = except(:order).limit!(1)
+        else
+          relation = except(:select, :distinct, :order)._select!(::ActiveRecord::FinderMethods::ONE_AS_ONE).limit!(1)
+        end
+
+        case conditions
+          # CPK
+          when CompositePrimaryKeys::CompositeKeys
+            relation = relation.where(cpk_id_predicate(table, primary_key, conditions))
+          # CPK
+          when Array
+            pk_length = @klass.primary_keys.length
+
+            if conditions.length == pk_length # E.g. conditions = ['France', 'Paris']
+              return self.construct_relation_for_exists(conditions.to_composite_keys)
+            else # Assume that conditions contains where relation
+              relation = relation.where(conditions)
+            end
+          when Array, Hash
+            relation.where!(conditions) unless conditions.empty?
+          else
+            relation.where!(primary_key => conditions) unless conditions == :none
+        end
+
+        relation
+      end
+
+      def find_with_ids(*ids)
+        raise UnknownPrimaryKey.new(@klass) if primary_key.nil?
+
+        # CPK
+        # expects_array = ids.first.kind_of?(Array)
+        ids = CompositePrimaryKeys.normalize(ids, @klass.primary_keys.length)
+        expects_array = ids.flatten != ids.flatten(1)
+        return ids.first if expects_array && ids.first.empty?
+
+        # CPK
+        # ids = ids.flatten.compact.uniq
+        ids = expects_array ? ids.first : ids
+
+        model_name = @klass.name
+
+        case ids.size
+        when 0
+          error_message = "Couldn't find #{model_name} without an ID"
+          raise ::ActiveRecord::RecordNotFound.new(error_message, model_name, primary_key)
+        when 1
+          result = find_one(ids.first)
+          expects_array ? [ result ] : result
+        else
+          find_some(ids)
+        end
+      end
+
+      # def last(limit = nil)
+      #   return find_last(limit) if loaded? || has_limit_or_offset?
+      #
+      #   result = limit(limit || 1)
+      #   # CPK
+      #   # result.order!(table[primary_key]) if order_values.empty? && primary_key
+      #   if order_values.empty? && primary_key
+      #     if composite?
+      #       result.order!(primary_keys.map { |pk| table[pk].asc })
+      #     elsif
+      #       result.order!(table[primary_key])
+      #     end
+      #   end
+      #
+      #   result = result.reverse_order!
+      #
+      #   limit ? result.reverse : result.first
+      # rescue ::ActiveRecord::IrreversibleOrderError
+      #   ActiveSupport::Deprecation.warn(<<-WARNING.squish)
+      #       Finding a last element by loading the relation when SQL ORDER
+      #       can not be reversed is deprecated.
+      #       Rails 5.1 will raise ActiveRecord::IrreversibleOrderError in this case.
+      #       Please call `to_a.last` if you still want to load the relation.
+      #   WARNING
+      #   find_last(limit)
+      # end
+
+      def find_one(id)
+        if ::ActiveRecord::Base === id
+          raise ArgumentError, <<-MSG.squish
+            You are passing an instance of ActiveRecord::Base to `find`.
+            Please pass the id of the object by calling `.id`.
+          MSG
+        end
+
+        # CPK
+        #relation = where(primary_key => id)
+        relation = where(cpk_id_predicate(table, primary_keys, id))
+        record = relation.take
+
+        raise_record_not_found_exception!(id, 0, 1) unless record
+
+        record
+      end
+
+      def find_some(ids)
+        # CPK
+        if composite?
+          ids = if ids.length == 1
+                  CompositePrimaryKeys::CompositeKeys.parse(ids.first)
+                else
+                  ids.to_composite_keys
+                end
+        end
+
+        return find_some_ordered(ids) unless order_values.present?
+
+        # CPK
+        # result = where(primary_key => ids).to_a
+        result = if composite?
+          result = where(cpk_in_predicate(table, primary_keys, ids)).to_a
+        else
+          result = where(primary_key => ids).to_a
+        end
+
+        expected_size =
+          if limit_value && ids.size > limit_value
+            limit_value
+          else
+            ids.size
+          end
+
+        # 11 ids with limit 3, offset 9 should give 2 results.
+        if offset_value && (ids.size - offset_value < expected_size)
+          expected_size = ids.size - offset_value
+        end
+
+        if result.size == expected_size
+          result
+        else
+          raise_record_not_found_exception!(ids, result.size, expected_size)
+        end
+      end
+
+      def find_some_ordered(ids)
+        ids = ids.slice(offset_value || 0, limit_value || ids.size) || []
+
+        # CPK
+        # result = except(:limit, :offset).where(primary_key => ids).records
+        result = if composite?
+          except(:limit, :offset).where(cpk_in_predicate(table, primary_keys, ids)).records
+        else
+          except(:limit, :offset).where(primary_key => ids).records
+        end
+
+        if result.size == ids.size
+          pk_type = @klass.type_for_attribute(primary_key)
+
+          records_by_id = result.index_by(&:id)
+          # CPK
+          # ids.map { |id| records_by_id.fetch(pk_type.cast(id)) }
+          if composite?
+            ids.map do |id|
+              typecasted_id = primary_keys.zip(id).map do |col, val|
+                @klass.type_for_attribute(col).cast(val)
+              end
+              records_by_id.fetch(typecasted_id)
+            end
+          else
+            ids.map { |id| records_by_id.fetch(pk_type.cast(id)) }
+          end
+        else
+          raise_record_not_found_exception!(ids, result.size, ids.size)
+        end
+      end
+
+      def ordered_relation
+        if order_values.empty? && (implicit_order_column || primary_key)
+          # CPK
+          # order(table[implicit_order_column || primary_key].asc)
+          order(Array(implicit_order_column || primary_key).map {|key| table[key].asc})
+        else
+          self
+        end
+      end
+    end
+  end
+end