groupdate 3.2.0 → 6.2.1

data/lib/groupdate/magic.rb

@@ -2,195 +2,53 @@ require "i18n"
 
 module Groupdate
   class Magic
-    attr_accessor :field, :options
+    DAYS = [:monday, :tuesday, :wednesday, :thursday, :friday, :saturday, :sunday]
 
-    def initialize(field, options)
-      @field = field
-      @options = options
-
-      raise Groupdate::Error, "Unrecognized time zone" unless time_zone
+    attr_accessor :period, :options, :group_index, :n_seconds
 
-      raise Groupdate::Error, "Unrecognized :week_start option" if field == :week && !week_start
-    end
+    def initialize(period:, **options)
+      @period = period
+      @options = options
 
-    def group_by(enum, &_block)
-      group = enum.group_by { |v| v = yield(v); v ? round_time(v) : nil }
-      series(group, [], false, false, false)
-    end
+      validate_keywords
+      validate_arguments
 
-    def relation(column, relation)
-      if relation.default_timezone == :local
-        raise Groupdate::Error, "ActiveRecord::Base.default_timezone must be :utc to use Groupdate"
+      if options[:n]
+        raise ArgumentError, "n must be a positive integer" if !options[:n].is_a?(Integer) || options[:n] < 1
+        @period = :custom
+        @n_seconds = options[:n].to_i
+        @n_seconds *= 60 if period == :minute
       end
+    end
 
-      time_zone = self.time_zone.tzinfo.name
-
-      adapter_name = relation.connection.adapter_name
-      query =
-        case adapter_name
-        when "MySQL", "Mysql2", "Mysql2Spatial"
-          case field
-          when :day_of_week # Sunday = 0, Monday = 1, etc
-            # use CONCAT for consistent return type (String)
-            ["DAYOFWEEK(CONVERT_TZ(DATE_SUB(#{column}, INTERVAL #{day_start} second), '+00:00', ?)) - 1", time_zone]
-          when :hour_of_day
-            ["(EXTRACT(HOUR from CONVERT_TZ(#{column}, '+00:00', ?)) + 24 - #{day_start / 3600}) % 24", time_zone]
-          when :day_of_month
-            ["DAYOFMONTH(CONVERT_TZ(DATE_SUB(#{column}, INTERVAL #{day_start} second), '+00:00', ?))", time_zone]
-          when :month_of_year
-            ["MONTH(CONVERT_TZ(DATE_SUB(#{column}, INTERVAL #{day_start} second), '+00:00', ?))", time_zone]
-          when :week
-            ["CONVERT_TZ(DATE_FORMAT(CONVERT_TZ(DATE_SUB(#{column}, INTERVAL ((#{7 - week_start} + WEEKDAY(CONVERT_TZ(#{column}, '+00:00', ?) - INTERVAL #{day_start} second)) % 7) DAY) - INTERVAL #{day_start} second, '+00:00', ?), '%Y-%m-%d 00:00:00') + INTERVAL #{day_start} second, ?, '+00:00')", time_zone, time_zone, time_zone]
-          when :quarter
-            ["DATE_ADD(CONVERT_TZ(DATE_FORMAT(DATE(CONCAT(EXTRACT(YEAR FROM CONVERT_TZ(DATE_SUB(#{column}, INTERVAL #{day_start} second), '+00:00', ?)), '-', LPAD(1 + 3 * (QUARTER(CONVERT_TZ(DATE_SUB(#{column}, INTERVAL #{day_start} second), '+00:00', ?)) - 1), 2, '00'), '-01')), '%Y-%m-%d %H:%i:%S'), ?, '+00:00'), INTERVAL #{day_start} second)", time_zone, time_zone, time_zone]
-          else
-            format =
-              case field
-              when :second
-                "%Y-%m-%d %H:%i:%S"
-              when :minute
-                "%Y-%m-%d %H:%i:00"
-              when :hour
-                "%Y-%m-%d %H:00:00"
-              when :day
-                "%Y-%m-%d 00:00:00"
-              when :month
-                "%Y-%m-01 00:00:00"
-              else # year
-                "%Y-01-01 00:00:00"
-              end
-
-            ["DATE_ADD(CONVERT_TZ(DATE_FORMAT(CONVERT_TZ(DATE_SUB(#{column}, INTERVAL #{day_start} second), '+00:00', ?), '#{format}'), ?, '+00:00'), INTERVAL #{day_start} second)", time_zone, time_zone]
-          end
-        when "PostgreSQL", "PostGIS"
-          case field
-          when :day_of_week
-            ["EXTRACT(DOW from #{column}::timestamptz AT TIME ZONE ? - INTERVAL '#{day_start} second')::integer", time_zone]
-          when :hour_of_day
-            ["EXTRACT(HOUR from #{column}::timestamptz AT TIME ZONE ? - INTERVAL '#{day_start} second')::integer", time_zone]
-          when :day_of_month
-            ["EXTRACT(DAY from #{column}::timestamptz AT TIME ZONE ? - INTERVAL '#{day_start} second')::integer", time_zone]
-          when :month_of_year
-            ["EXTRACT(MONTH from #{column}::timestamptz AT TIME ZONE ? - INTERVAL '#{day_start} second')::integer", time_zone]
-          when :week # start on Sunday, not PostgreSQL default Monday
-            ["(DATE_TRUNC('#{field}', (#{column}::timestamptz - INTERVAL '#{week_start} day' - INTERVAL '#{day_start} second') AT TIME ZONE ?) + INTERVAL '#{week_start} day' + INTERVAL '#{day_start} second') AT TIME ZONE ?", time_zone, time_zone]
-          else
-            ["(DATE_TRUNC('#{field}', (#{column}::timestamptz - INTERVAL '#{day_start} second') AT TIME ZONE ?) + INTERVAL '#{day_start} second') AT TIME ZONE ?", time_zone, time_zone]
-          end
-        when "SQLite"
-          raise Groupdate::Error, "Time zones not supported for SQLite" unless self.time_zone.utc_offset.zero?
-          raise Groupdate::Error, "day_start not supported for SQLite" unless day_start.zero?
-          raise Groupdate::Error, "week_start not supported for SQLite" unless week_start == 6
-
-          if field == :week
-            ["strftime('%%Y-%%m-%%d 00:00:00 UTC', #{column}, '-6 days', 'weekday 0')"]
-          else
-            format =
-              case field
-                when :hour_of_day
-                  "%H"
-                when :day_of_week
-                  "%w"
-                when :day_of_month
-                  "%d"
-                when :month_of_year
-                  "%m"
-                when :second
-                  "%Y-%m-%d %H:%M:%S UTC"
-                when :minute
-                  "%Y-%m-%d %H:%M:00 UTC"
-                when :hour
-                  "%Y-%m-%d %H:00:00 UTC"
-                when :day
-                  "%Y-%m-%d 00:00:00 UTC"
-                when :month
-                  "%Y-%m-01 00:00:00 UTC"
-                when :quarter
-                  raise Groupdate::Error, "Quarter not supported for SQLite"
-                else # year
-                  "%Y-01-01 00:00:00 UTC"
-                end
-
-            ["strftime('#{format.gsub(/%/, '%%')}', #{column})"]
-          end
-        when "Redshift"
-          case field
-          when :day_of_week # Sunday = 0, Monday = 1, etc.
-            ["EXTRACT(DOW from CONVERT_TIMEZONE(?, #{column}::timestamp) - INTERVAL '#{day_start} second')::integer", time_zone]
-          when :hour_of_day
-            ["EXTRACT(HOUR from CONVERT_TIMEZONE(?, #{column}::timestamp) - INTERVAL '#{day_start} second')::integer", time_zone]
-          when :day_of_month
-            ["EXTRACT(DAY from CONVERT_TIMEZONE(?, #{column}::timestamp) - INTERVAL '#{day_start} second')::integer", time_zone]
-          when :month_of_year
-            ["EXTRACT(MONTH from CONVERT_TIMEZONE(?, #{column}::timestamp) - INTERVAL '#{day_start} second')::integer", time_zone]
-          when :week # start on Sunday, not Redshift default Monday
-            # Redshift does not return timezone information; it
-            # always says it is in UTC time, so we must convert
-            # back to UTC to play properly with the rest of Groupdate.
-            #
-            ["CONVERT_TIMEZONE(?, 'Etc/UTC', DATE_TRUNC(?, CONVERT_TIMEZONE(?, #{column}) - INTERVAL '#{week_start} day' - INTERVAL '#{day_start} second'))::timestamp + INTERVAL '#{week_start} day' + INTERVAL '#{day_start} second'", time_zone, field, time_zone]
-          else
-            ["CONVERT_TIMEZONE(?, 'Etc/UTC', DATE_TRUNC(?, CONVERT_TIMEZONE(?, #{column}) - INTERVAL '#{day_start} second'))::timestamp + INTERVAL '#{day_start} second'", time_zone, field, time_zone]
-          end
-        else
-          raise Groupdate::Error, "Connection adapter not supported: #{adapter_name}"
-        end
+    def validate_keywords
+      known_keywords = [:time_zone, :series, :format, :locale, :range, :expand_range, :reverse]
 
-      if adapter_name == "MySQL" && field == :week
-        query[0] = "CAST(#{query[0]} AS DATETIME)"
+      if %i[week day_of_week].include?(period)
+        known_keywords << :week_start
       end
 
-      group = relation.group(Groupdate::OrderHack.new(relation.send(:sanitize_sql_array, query), field, time_zone))
-      relation =
-        if time_range.is_a?(Range)
-          # doesn't matter whether we include the end of a ... range - it will be excluded later
-          group.where("#{column} >= ? AND #{column} <= ?", time_range.first, time_range.last)
-        else
-          group.where("#{column} IS NOT NULL")
-        end
-
-      # TODO do not change object state
-      @group_index = group.group_values.size - 1
-
-      Groupdate::Series.new(self, relation)
-    end
-
-    def perform(relation, method, *args, &block)
-      # undo reverse since we do not want this to appear in the query
-      reverse = relation.send(:reverse_order_value)
-      relation = relation.except(:reverse_order) if reverse
-      order = relation.order_values.first
-      if order.is_a?(String)
-        parts = order.split(" ")
-        reverse_order = (parts.size == 2 && (parts[0].to_sym == field || (activerecord42? && parts[0] == "#{relation.quoted_table_name}.#{relation.quoted_primary_key}")) && parts[1].to_s.downcase == "desc")
-        if reverse_order
-          reverse = !reverse
-          relation = relation.reorder(relation.order_values[1..-1])
-        end
+      if %i[day week month quarter year day_of_week hour_of_day day_of_month day_of_year month_of_year].include?(period)
+        known_keywords << :day_start
+      else
+        # prevent Groupdate.day_start from applying
+        @day_start = 0
       end
 
-      multiple_groups = relation.group_values.size > 1
-
-      cast_method =
-        case field
-        when :day_of_week, :hour_of_day, :day_of_month, :month_of_year
-          lambda { |k| k.to_i }
-        else
-          utc = ActiveSupport::TimeZone["UTC"]
-          lambda { |k| (k.is_a?(String) || !k.respond_to?(:to_time) ? utc.parse(k.to_s) : k.to_time).in_time_zone(time_zone) }
-        end
-
-      result = relation.send(method, *args, &block)
-      missing_time_zone_support = multiple_groups ? (result.keys.first && result.keys.first[@group_index].nil?) : result.key?(nil)
-      if missing_time_zone_support
-        raise Groupdate::Error, "Be sure to install time zone support - https://github.com/ankane/groupdate#for-mysql"
+      if %i[second minute].include?(period)
+        known_keywords << :n
       end
-      result = Hash[result.map { |k, v| [multiple_groups ? k[0...@group_index] + [cast_method.call(k[@group_index])] + k[(@group_index + 1)..-1] : cast_method.call(k), v] }]
 
-      series(result, (options.key?(:default_value) ? options[:default_value] : 0), multiple_groups, reverse)
+      unknown_keywords = options.keys - known_keywords
+      raise ArgumentError, "unknown keywords: #{unknown_keywords.join(", ")}" if unknown_keywords.any?
     end
 
-    protected
+    def validate_arguments
+      # TODO better messages
+      raise ArgumentError, "Unrecognized time zone" unless time_zone
+      raise ArgumentError, "Unrecognized :week_start option" unless week_start
+      raise ArgumentError, ":day_start must be between 0 and 24" if (day_start / 3600) < 0 || (day_start / 3600) >= 24
+    end
 
     def time_zone
       @time_zone ||= begin
@@ -201,198 +59,209 @@ module Groupdate
     end
 
     def week_start
-      @week_start ||= [:mon, :tue, :wed, :thu, :fri, :sat, :sun].index((options[:week_start] || options[:start] || Groupdate.week_start).to_sym)
+      @week_start ||= begin
+        v = (options[:week_start] || Groupdate.week_start).to_sym
+        DAYS.index(v) || [:mon, :tue, :wed, :thu, :fri, :sat, :sun].index(v)
+      end
     end
 
     def day_start
       @day_start ||= ((options[:day_start] || Groupdate.day_start).to_f * 3600).round
     end
 
-    def time_range
-      @time_range ||= begin
+    def range
+      @range ||= begin
         time_range = options[:range]
-        if time_range.is_a?(Range) && time_range.first.is_a?(Date)
-          # convert range of dates to range of times
-          # use parsing instead of in_time_zone due to Rails < 4
-          last = time_zone.parse(time_range.last.to_s)
-          last += 1.day unless time_range.exclude_end?
-          time_range = Range.new(time_zone.parse(time_range.first.to_s), last, true)
-        elsif !time_range && options[:last]
-          if field == :quarter
-            step = 3.months
-          elsif 1.respond_to?(field)
-            step = 1.send(field)
-          else
-            raise ArgumentError, "Cannot use last option with #{field}"
-          end
-          if step
-            now = Time.now
-            # loop instead of multiply to change start_at - see #151
-            start_at = now
-            (options[:last].to_i - 1).times do
-              start_at -= step
-            end
 
-            time_range =
-              if options[:current] == false
-                round_time(start_at - step)...round_time(now)
-              else
-                round_time(start_at)..now
-              end
-          end
+        if time_range.is_a?(Range) && time_range.begin.nil? && time_range.end.nil?
+          nil
+        else
+          time_range
         end
-        time_range
       end
     end
 
-    def series(count, default_value, multiple_groups = false, reverse = false, series_default = true)
-      reverse = !reverse if options[:reverse]
-
-      series =
-        case field
-        when :day_of_week
-          0..6
-        when :hour_of_day
-          0..23
-        when :day_of_month
-          1..31
-        when :month_of_year
-          1..12
-        else
-          time_range = self.time_range
-          time_range =
-            if time_range.is_a?(Range)
-              time_range
-            else
-              # use first and last values
-              sorted_keys =
-                if multiple_groups
-                  count.keys.map { |k| k[@group_index] }.sort
-                else
-                  count.keys.sort
-                end
-              sorted_keys.first..sorted_keys.last
-            end
+    def series_builder
+      @series_builder ||=
+        SeriesBuilder.new(
+          **options,
+          period: period,
+          time_zone: time_zone,
+          range: range,
+          day_start: day_start,
+          week_start: week_start,
+          n_seconds: n_seconds
+        )
+    end
 
-          if time_range.first
-            series = [round_time(time_range.first)]
+    def time_range
+      series_builder.time_range
+    end
 
-            if field == :quarter
-              step = 3.months
-            else
-              step = 1.send(field)
-            end
+    def self.validate_period(period, permit)
+      permitted_periods = ((permit || Groupdate::PERIODS).map(&:to_sym) & Groupdate::PERIODS).map(&:to_s)
+      raise ArgumentError, "Unpermitted period" unless permitted_periods.include?(period.to_s)
+    end
 
-            last_step = series.last
-            while (next_step = round_time(last_step + step)) && time_range.cover?(next_step)
-              if next_step == last_step
-                last_step += step
-                next
-              end
-              series << next_step
-              last_step = next_step
-            end
+    class Enumerable < Magic
+      def group_by(enum, &_block)
+        group = enum.group_by do |v|
+          v = yield(v)
+          raise ArgumentError, "Not a time" unless v.respond_to?(:to_time)
+          series_builder.round_time(v)
+        end
+        series_builder.generate(group, default_value: [], series_default: false)
+      end
 
-            series
+      def self.group_by(enum, period, options, &block)
+        Groupdate::Magic::Enumerable.new(period: period, **options).group_by(enum, &block)
+      end
+    end
+
+    class Relation < Magic
+      def initialize(**options)
+        super(**options.reject { |k, _| [:default_value, :carry_forward, :last, :current].include?(k) })
+        @options = options
+      end
+
+      def perform(relation, result, default_value:)
+        if defined?(ActiveRecord::Promise) && result.is_a?(ActiveRecord::Promise)
+          return result.then { |r| perform(relation, r, default_value: default_value) }
+        end
+
+        multiple_groups = relation.group_values.size > 1
+
+        check_nils(result, multiple_groups, relation)
+        result = cast_result(result, multiple_groups)
+
+        series_builder.generate(
+          result,
+          default_value: options.key?(:default_value) ? options[:default_value] : default_value,
+          multiple_groups: multiple_groups,
+          group_index: group_index
+        )
+      end
+
+      def cast_method
+        @cast_method ||= begin
+          case period
+          when :minute_of_hour, :hour_of_day, :day_of_month, :day_of_year, :month_of_year
+            lambda { |k| k.to_i }
+          when :day_of_week
+            lambda { |k| (k.to_i - 1 - week_start) % 7 }
+          when :day, :week, :month, :quarter, :year
+            # TODO keep as date
+            if day_start != 0
+              day_start_hour = day_start / 3600
+              day_start_min = (day_start % 3600) / 60
+              day_start_sec = (day_start % 3600) % 60
+              lambda { |k| k.in_time_zone(time_zone).change(hour: day_start_hour, min: day_start_min, sec: day_start_sec) }
+            else
+              lambda { |k| k.in_time_zone(time_zone) }
+            end
           else
-            []
+            utc = ActiveSupport::TimeZone["UTC"]
+            lambda { |k| (k.is_a?(String) || !k.respond_to?(:to_time) ? utc.parse(k.to_s) : k.to_time).in_time_zone(time_zone) }
           end
         end
+      end
 
-      series =
-        if multiple_groups
-          keys = count.keys.map { |k| k[0...@group_index] + k[(@group_index + 1)..-1] }.uniq
-          series = series.to_a.reverse if reverse
-          keys.flat_map do |k|
-            series.map { |s| k[0...@group_index] + [s] + k[@group_index..-1] }
+      def cast_result(result, multiple_groups)
+        new_result = {}
+        result.each do |k, v|
+          if multiple_groups
+            k[group_index] = cast_method.call(k[group_index])
+          else
+            k = cast_method.call(k)
           end
-        else
-          series
+          new_result[k] = v
         end
+        new_result
+      end
 
-      # reversed above if multiple groups
-      series = series.to_a.reverse if !multiple_groups && reverse
+      def time_zone_support?(relation)
+        if relation.connection.adapter_name =~ /mysql/i
+          # need to call klass for Rails < 5.2
+          sql = relation.klass.send(:sanitize_sql_array, ["SELECT CONVERT_TZ(NOW(), '+00:00', ?)", time_zone.tzinfo.name])
+          !relation.connection.select_all(sql).first.values.first.nil?
+        else
+          true
+        end
+      end
 
-      locale = options[:locale] || I18n.locale
-      use_dates = options.key?(:dates) ? options[:dates] : Groupdate.dates
-      key_format =
-        if options[:format]
-          if options[:format].respond_to?(:call)
-            options[:format]
+      def check_nils(result, multiple_groups, relation)
+        has_nils = multiple_groups ? (result.keys.first && result.keys.first[group_index].nil?) : result.key?(nil)
+        if has_nils
+          if time_zone_support?(relation)
+            raise Groupdate::Error, "Invalid query - be sure to use a date or time column"
           else
-            sunday = time_zone.parse("2014-03-02 00:00:00")
-            lambda do |key|
-              case field
-              when :hour_of_day
-                key = sunday + key.hours + day_start.seconds
-              when :day_of_week
-                key = sunday + key.days
-              when :day_of_month
-                key = Date.new(2014, 1, key).to_time
-              when :month_of_year
-                key = Date.new(2014, key, 1).to_time
-              end
-              I18n.localize(key, format: options[:format], locale: locale)
-            end
+            raise Groupdate::Error, "Database missing time zone support for #{time_zone.tzinfo.name} - see https://github.com/ankane/groupdate#for-mysql"
           end
-        elsif [:day, :week, :month, :quarter, :year].include?(field) && use_dates
-          lambda { |k| k.to_date }
-        else
-          lambda { |k| k }
         end
-
-      use_series = options.key?(:series) ? options[:series] : series_default
-      if use_series == false
-        series = series.select { |k| count[k] }
       end
 
-      value = 0
-      Hash[series.map do |k|
-        value = count[k] || (@options[:carry_forward] && value) || default_value
-        [multiple_groups ? k[0...@group_index] + [key_format.call(k[@group_index])] + k[(@group_index + 1)..-1] : key_format.call(k), value]
-      end]
-    end
+      def self.generate_relation(relation, field:, **options)
+        magic = Groupdate::Magic::Relation.new(**options)
+
+        adapter_name = relation.connection.adapter_name
+        adapter = Groupdate.adapters[adapter_name]
+        raise Groupdate::Error, "Connection adapter not supported: #{adapter_name}" unless adapter
+
+        # very important
+        column = validate_column(field)
+        column = resolve_column(relation, column)
+
+        # generate ActiveRecord relation
+        relation =
+          adapter.new(
+            relation,
+            column: column,
+            period: magic.period,
+            time_zone: magic.time_zone,
+            time_range: magic.time_range,
+            week_start: magic.week_start,
+            day_start: magic.day_start,
+            n_seconds: magic.n_seconds
+          ).generate
+
+        # add Groupdate info
+        magic.group_index = relation.group_values.size - 1
+        (relation.groupdate_values ||= []) << magic
+
+        relation
+      end
 
-    def round_time(time)
-      time = time.to_time.in_time_zone(time_zone) - day_start.seconds
-
-      time =
-        case field
-        when :second
-          time.change(usec: 0)
-        when :minute
-          time.change(sec: 0)
-        when :hour
-          time.change(min: 0)
-        when :day
-          time.beginning_of_day
-        when :week
-          # same logic as MySQL group
-          weekday = (time.wday - 1) % 7
-          (time - ((7 - week_start + weekday) % 7).days).midnight
-        when :month
-          time.beginning_of_month
-        when :quarter
-          time.beginning_of_quarter
-        when :year
-          time.beginning_of_year
-        when :hour_of_day
-          time.hour
-        when :day_of_week
-          time.wday
-        when :day_of_month
-          time.day
-        when :month_of_year
-          time.month
-        else
-          raise Groupdate::Error, "Invalid field"
+      class << self
+        # basic version of Active Record disallow_raw_sql!
+        # symbol = column (safe), Arel node = SQL (safe), other = untrusted
+        # matches table.column and column
+        def validate_column(column)
+          unless column.is_a?(Symbol) || column.is_a?(Arel::Nodes::SqlLiteral)
+            column = column.to_s
+            unless /\A\w+(\.\w+)?\z/i.match(column)
+              raise ActiveRecord::UnknownAttributeReference, "Query method called with non-attribute argument(s): #{column.inspect}. Use Arel.sql() for known-safe values."
+            end
+          end
+          column
         end
 
-      time.is_a?(Time) ? time + day_start.seconds : time
-    end
+        # resolves eagerly
+        # need to convert both where_clause (easy)
+        # and group_clause (not easy) if want to avoid this
+        def resolve_column(relation, column)
+          node = relation.send(:relation).send(:arel_columns, [column]).first
+          node = Arel::Nodes::SqlLiteral.new(node) if node.is_a?(String)
+          relation.connection.visitor.accept(node, Arel::Collectors::SQLString.new).value
+        end
+      end
 
-    def activerecord42?
-      ActiveRecord::VERSION::STRING.starts_with?("4.2.")
+      # allow any options to keep flexible for future
+      def self.process_result(relation, result, **options)
+        relation.groupdate_values.reverse.each do |gv|
+          result = gv.perform(relation, result, default_value: options[:default_value])
+        end
+        result
+      end
     end
   end
 end

data/lib/groupdate/query_methods.rb

@@ -0,0 +1,18 @@
+module Groupdate
+  module QueryMethods
+    Groupdate::PERIODS.each do |period|
+      define_method :"group_by_#{period}" do |field, **options|
+        Groupdate::Magic::Relation.generate_relation(self,
+          period: period,
+          field: field,
+          **options
+        )
+      end
+    end
+
+    def group_by_period(period, field, permit: nil, **options)
+      Groupdate::Magic.validate_period(period, permit)
+      send("group_by_#{period}", field, **options)
+    end
+  end
+end

data/lib/groupdate/relation.rb

@@ -0,0 +1,19 @@
+require "active_support/concern"
+
+module Groupdate
+  module Relation
+    extend ActiveSupport::Concern
+
+    included do
+      attr_accessor :groupdate_values
+    end
+
+    def calculate(*args, &block)
+      # prevent calculate from being called twice
+      return super if ActiveRecord::VERSION::STRING.to_f >= 6.1 && has_include?(args[1])
+
+      default_value = [:count, :sum].include?(args[0]) ? 0 : nil
+      Groupdate.process_result(self, super, default_value: default_value)
+    end
+  end
+end