groupdate 5.2.4 → 6.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2b6c83f192d439e35025586a076762413d80daab15b85e81561404bdf078acad
-  data.tar.gz: 382dd612bbd1db8e131345981576b7a6c61c525d8a991fb8a3fc60678ce8d6ef
+  metadata.gz: a8f13f0acf7f0343411da5d22ddeef37e132971142ef849f72998caa78a32eba
+  data.tar.gz: c79112d5544778a1597e7723fc2b7ec6dfc45c906c7707aa74970ad007b01de0
 SHA512:
-  metadata.gz: 2d33022921907669f28eed522daec36e84552aabd41a411ff556923c0029cc72a003d30cd9cbeecba27e3d795fc279f71ca05a01cbc8c5cf6a0bd7256a478f72
-  data.tar.gz: 87c778a1972590cc6609a3c5a096fef6dde88c70ab663b5ebac820de89ec356359f802ea1d8ba38280378e877caabb1974e1d6a81c689eef92e6d7accf2f356a
+  metadata.gz: 750c32b3729bda086a69107fbccbed3be1b5e4ad5d56c8e266c8a896856ed1a2364ff537a8d0e78af161d2d6fc74ad23f666b99876216f597e4db44b83f85cc3
+  data.tar.gz: 9770b962557af2e2f6356a1594c93e3b60d781bd637c1b34e78a2d241cb7842740652bbec15c2a959a1d9dadf304ef71c159b9985219a1a295d8342013892f58

data/CHANGELOG.md

@@ -1,3 +1,59 @@
+## 6.8.0 (2026-04-04)
+
+- Dropped support for Ruby < 3.3 and Active Record < 7.2
+
+## 6.7.0 (2025-06-02)
+
+- Added time zone support for SQLite
+- Added `day_start` support for SQLite
+- Added `group_by_quarter` support for SQLite
+
+## 6.6.0 (2025-05-04)
+
+- Dropped support for Ruby < 3.2 and Active Record < 7.1
+
+## 6.5.1 (2024-10-07)
+
+- Fixed connection leasing for Active Record 7.2+
+
+## 6.5.0 (2024-10-01)
+
+- Added support for Active Record 8
+- Dropped support for Ruby < 3.1 and Active Record < 7
+
+## 6.4.0 (2023-09-13)
+
+- Added support for Trilogy
+
+## 6.3.0 (2023-07-02)
+
+- Dropped support for Ruby < 3 and Rails < 6.1
+
+## 6.2.1 (2023-04-18)
+
+- Fixed extra day with `DateTime` ranges
+
+## 6.2.0 (2023-01-29)
+
+- Added support for async methods with Active Record 7.1
+
+## 6.1.0 (2022-04-05)
+
+- Added `expand_range` option
+
+## 6.0.1 (2022-01-16)
+
+- Fixed incorrect results (error before 6.0) with `includes` with Active Record 6.1+
+
+## 6.0.0 (2022-01-15)
+
+- Raise `ActiveRecord::UnknownAttributeReference` for non-attribute arguments
+- Raise `ArgumentError` for ranges with string bounds
+- Added `n` option for Redshift
+- Changed SQL to return dates instead of times for day, week, month, quarter, and year
+- Removed `dates` option
+- Dropped support for Ruby < 2.6 and Rails < 5.2
+
 ## 5.2.4 (2021-12-15)
 
 - Simplified queries for Active Record 7 and MySQL
@@ -140,7 +196,7 @@ Breaking changes
 - Added `default_value` option
 - Accept symbol for `format` option
 - Raise `ArgumentError` if no field specified
-- Added support for ActiveRecord 5 beta
+- Added support for Active Record 5 beta
 
 ## 2.5.0 (2015-09-29)
 
@@ -154,18 +210,18 @@ Breaking changes
 - Added `carry_forward` option
 - Added `series: false` option for arrays and hashes
 - Fixed issue w/ Brasilia Summer Time
-- Fixed issues w/ ActiveRecord 4.2
+- Fixed issues w/ Active Record 4.2
 
 ## 2.3.0 (2014-08-31)
 
-- Raise error when ActiveRecord::Base.default_timezone is not `:utc`
+- Raise error when `ActiveRecord::Base.default_timezone` is not `:utc`
 - Added `day_of_month`
 - Added `month_of_year`
 - Do not quote column name
 
 ## 2.2.1 (2014-06-23)
 
-- Fixed ActiveRecord 3 associations
+- Fixed Active Record 3 associations
 
 ## 2.2.0 (2014-06-22)
 
@@ -230,3 +286,44 @@ Breaking changes
 ## 1.0.0 (2013-05-15)
 
 - First major release
+
+## 0.1.6 (2013-05-07)
+
+- Fixed error with Ruby 1.8
+
+## 0.1.5 (2013-05-01)
+
+- Added support for getting the entire series
+
+## 0.1.4 (2013-05-01)
+
+- Added support for Ruby 1.8
+
+## 0.1.3 (2013-04-25)
+
+- Improved field names for ordering
+
+## 0.1.2 (2013-04-24)
+
+- Added ability to order easily
+
+## 0.1.1 (2013-04-21)
+
+- Improved return types for MySQL
+
+## 0.1.0 (2013-04-21)
+
+- Added `day_of_week`
+- Added `hour_of_day`
+
+## 0.0.3 (2013-04-18)
+
+- Added support for Rails time zone strings
+
+## 0.0.2 (2013-04-18)
+
+- Added tests
+
+## 0.0.1 (2013-04-17)
+
+- First release

data/LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2013-2021 Andrew Kane
+Copyright (c) 2013-2025 Andrew Kane
 
 MIT License
 

data/README.md

@@ -11,30 +11,30 @@ The simplest way to group by:
 
 :cake: Get the entire series - **the other best part**
 
-Supports PostgreSQL, MySQL, and Redshift, plus arrays and hashes (and limited support for [SQLite](#for-sqlite))
+Supports PostgreSQL, MySQL, MariaDB, SQLite, and Redshift, plus arrays and hashes
 
 :cupid: Goes hand in hand with [Chartkick](https://www.chartkick.com)
 
-[![Build Status](https://github.com/ankane/groupdate/workflows/build/badge.svg?branch=master)](https://github.com/ankane/groupdate/actions)
+[![Build Status](https://github.com/ankane/groupdate/actions/workflows/build.yml/badge.svg)](https://github.com/ankane/groupdate/actions)
 
 ## Installation
 
 Add this line to your application’s Gemfile:
 
 ```ruby
-gem 'groupdate'
+gem "groupdate"
 ```
 
-For MySQL and SQLite, also follow [these instructions](#additional-instructions).
+For MySQL and MariaDB, also follow [these instructions](#additional-instructions).
 
 ## Getting Started
 
 ```ruby
 User.group_by_day(:created_at).count
 # {
-#   Sat, 24 May 2020 => 50,
-#   Sun, 25 May 2020 => 100,
-#   Mon, 26 May 2020 => 34
+#   Wed, 01 Jan 2025 => 50,
+#   Thu, 02 Jan 2025 => 100,
+#   Fri, 03 Jan 2025 => 34
 # }
 ```
 
@@ -75,9 +75,9 @@ or
 ```ruby
 User.group_by_week(:created_at, time_zone: "Pacific Time (US & Canada)").count
 # {
-#   Sun, 08 Mar 2020 => 70,
-#   Sun, 15 Mar 2020 => 54,
-#   Sun, 22 Mar 2020 => 80
+#   Sun, 05 Jan 2025 => 70,
+#   Sun, 12 Jan 2025 => 54,
+#   Sun, 19 Jan 2025 => 80
 # }
 ```
 
@@ -119,6 +119,12 @@ To get a specific time range, use:
 User.group_by_day(:created_at, range: 2.weeks.ago.midnight..Time.now).count
 ```
 
+To expand the range to the start and end of the time period, use:
+
+```ruby
+User.group_by_day(:created_at, range: 2.weeks.ago..Time.now, expand_range: true).count
+```
+
 To get the most recent time periods, use:
 
 ```ruby
@@ -148,8 +154,8 @@ To get keys in a different format, use:
 ```ruby
 User.group_by_month(:created_at, format: "%b %Y").count
 # {
-#   "Jan 2020" => 10
-#   "Feb 2020" => 12
+#   "Jan 2025" => 10
+#   "Feb 2025" => 12
 # }
 ```
 
@@ -164,7 +170,7 @@ User.group_by_hour_of_day(:created_at, format: "%-l %P").count
 # }
 ```
 
-Takes a `String`, which is passed to [strftime](http://strfti.me/), or a `Symbol`, which is looked up by `I18n.localize` in `i18n` scope 'time.formats', or a `Proc`.  You can pass a locale with the `locale` option.
+Takes a `String`, which is passed to [strftime](https://www.strfti.me/), or a `Symbol`, which is looked up by `I18n.localize` in `i18n` scope 'time.formats', or a `Proc`.  You can pass a locale with the `locale` option.
 
 ### Series
 
@@ -210,19 +216,6 @@ If grouping on date columns which don’t need time zone conversion, use:
 User.group_by_week(:created_on, time_zone: false).count
 ```
 
-### User Input
-
-If passing user input as the column, be sure to sanitize it first [like you must](https://rails-sqli.org/) with `group`.
-
-```ruby
-column = params[:column]
-
-# check against permitted columns
-raise "Unpermitted column" unless ["column_a", "column_b"].include?(column)
-
-User.group_by_day(column).count
-```
-
 ### Default Scopes
 
 If you use Postgres and have a default scope that uses `order`, you may get a `column must appear in the GROUP BY clause` error (just like with Active Record’s `group` method). Remove the `order` scope with:
@@ -252,12 +245,14 @@ users.group_by_day(series: true) { |u| u.created_at }
 Count
 
 ```ruby
-users.group_by_day { |u| u.created_at }.map { |k, v| [k, v.count] }.to_h
+users.group_by_day { |u| u.created_at }.to_h { |k, v| [k, v.count] }
 ```
 
 ## Additional Instructions
 
-### For MySQL
+<a name="for-mysql"></a>
+
+### For MySQL and MariaDB
 
 [Time zone support](https://dev.mysql.com/doc/refman/8.0/en/time-zone-support.html) must be installed on the server.
 
@@ -273,30 +268,6 @@ SELECT CONVERT_TZ(NOW(), '+00:00', 'Pacific/Honolulu');
 
 It should return the time instead of `NULL`.
 
-### For SQLite
-
-Groupdate has limited support for SQLite.
-
-- No time zone support
-- No `day_start` option
-- No `group_by_quarter` method
-
-If your application’s time zone is set to something other than `Etc/UTC` (the default), create an initializer with:
-
-```ruby
-Groupdate.time_zone = false
-```
-
-## Upgrading
-
-### 5.0
-
-Groupdate 5.0 brings a number of improvements. Here are a few to be aware of:
-
-- The `week_start` option is now supported for SQLite
-- The `day_start` option is now consistent between Active Record and enumerable
-- Deprecated positional arguments for time zone and range have been removed
-
 ## History
 
 View the [changelog](https://github.com/ankane/groupdate/blob/master/CHANGELOG.md)

data/lib/groupdate/adapters/base_adapter.rb

@@ -3,27 +3,19 @@ module Groupdate
     class BaseAdapter
       attr_reader :period, :column, :day_start, :week_start, :n_seconds
 
-      def initialize(relation, column:, period:, time_zone:, time_range:, week_start:, day_start:, n_seconds:)
-        # very important
-        column = validate_column(column)
-
+      def initialize(relation, column:, period:, time_zone:, time_range:, week_start:, day_start:, n_seconds:, adapter_name: nil)
         @relation = relation
-        @column = resolve_column(relation, column)
+        @column = column
         @period = period
         @time_zone = time_zone
         @time_range = time_range
         @week_start = week_start
         @day_start = day_start
         @n_seconds = n_seconds
+        @adapter_name = adapter_name
 
-        if ActiveRecord::VERSION::MAJOR >= 7
-          if ActiveRecord.default_timezone == :local
-            raise Groupdate::Error, "ActiveRecord.default_timezone must be :utc to use Groupdate"
-          end
-        else
-          if relation.default_timezone == :local
-            raise Groupdate::Error, "ActiveRecord::Base.default_timezone must be :utc to use Groupdate"
-          end
+        if ActiveRecord.default_timezone == :local
+          raise Groupdate::Error, "ActiveRecord.default_timezone must be :utc to use Groupdate"
         end
       end
 
@@ -49,28 +41,6 @@ module Groupdate
           ["#{column} IS NOT NULL"]
         end
       end
-
-      # 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)
-            warn "[groupdate] Non-attribute argument: #{column}. Use Arel.sql() for known-safe values. This will raise an error in Groupdate 6"
-          end
-        end
-        column
-      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
   end
 end

data/lib/groupdate/adapters/mysql_adapter.rb

@@ -20,9 +20,21 @@ module Groupdate
           when :month_of_year
             ["MONTH(#{day_start_column})", time_zone, day_start]
           when :week
-            ["CONVERT_TZ(DATE_FORMAT(#{day_start_column} - INTERVAL ((? + DAYOFWEEK(#{day_start_column})) % 7) DAY, '%Y-%m-%d 00:00:00') + INTERVAL ? second, ?, '+00:00')", time_zone, day_start, 12 - week_start, time_zone, day_start, day_start, time_zone]
+            ["CAST(DATE_FORMAT(#{day_start_column} - INTERVAL ((? + DAYOFWEEK(#{day_start_column})) % 7) DAY, '%Y-%m-%d') AS DATE)", time_zone, day_start, 12 - week_start, time_zone, day_start]
           when :quarter
-            ["CONVERT_TZ(DATE_FORMAT(DATE(CONCAT(YEAR(#{day_start_column}), '-', LPAD(1 + 3 * (QUARTER(#{day_start_column}) - 1), 2, '00'), '-01')), '%Y-%m-%d %H:%i:%S') + INTERVAL ? second, ?, '+00:00')", time_zone, day_start, time_zone, day_start, day_start, time_zone]
+            ["CAST(CONCAT(YEAR(#{day_start_column}), '-', LPAD(1 + 3 * (QUARTER(#{day_start_column}) - 1), 2, '00'), '-01') AS DATE)", time_zone, day_start, time_zone, day_start]
+          when :day, :month, :year
+            format =
+              case period
+              when :day
+                "%Y-%m-%d"
+              when :month
+                "%Y-%m-01"
+              else # year
+                "%Y-01-01"
+              end
+
+            ["CAST(DATE_FORMAT(#{day_start_column}, ?) AS DATE)", time_zone, day_start, format]
           when :custom
             ["FROM_UNIXTIME((UNIX_TIMESTAMP(#{column}) DIV ?) * ?)", n_seconds, n_seconds]
           else
@@ -32,14 +44,8 @@ module Groupdate
                 "%Y-%m-%d %H:%i:%S"
               when :minute
                 "%Y-%m-%d %H:%i:00"
-              when :hour
+              else # 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
 
             ["CONVERT_TZ(DATE_FORMAT(#{day_start_column}, ?) + INTERVAL ? second, ?, '+00:00')", time_zone, day_start, format, day_start, time_zone]

data/lib/groupdate/adapters/postgresql_adapter.rb

@@ -21,16 +21,18 @@ module Groupdate
           when :month_of_year
             ["EXTRACT(MONTH FROM #{day_start_column})::integer", time_zone, day_start_interval]
           when :week
-            ["(DATE_TRUNC('day', #{day_start_column} - INTERVAL '1 day' * ((? + EXTRACT(DOW FROM #{day_start_column})::integer) % 7)) + INTERVAL ?) AT TIME ZONE ?", time_zone, day_start_interval, 13 - week_start, time_zone, day_start_interval, day_start_interval, time_zone]
+            ["(DATE_TRUNC('day', #{day_start_column} - INTERVAL '1 day' * ((? + EXTRACT(DOW FROM #{day_start_column})::integer) % 7)) + INTERVAL ?)::date", time_zone, day_start_interval, 13 - week_start, time_zone, day_start_interval, day_start_interval]
           when :custom
-            ["TO_TIMESTAMP(FLOOR(EXTRACT(EPOCH FROM #{column}::timestamptz) / ?) * ?)", n_seconds, n_seconds]
-          else
-            if day_start == 0
-              # prettier
-              ["DATE_TRUNC(?, #{day_start_column}) AT TIME ZONE ?", period, time_zone, day_start_interval, time_zone]
+            if @adapter_name == "Redshift"
+              ["TIMESTAMP 'epoch' + (FLOOR(EXTRACT(EPOCH FROM #{column}::timestamp) / ?) * ?) * INTERVAL '1 second'", n_seconds, n_seconds]
             else
-              ["(DATE_TRUNC(?, #{day_start_column}) + INTERVAL ?) AT TIME ZONE ?", period, time_zone, day_start_interval, day_start_interval, time_zone]
+              ["TO_TIMESTAMP(FLOOR(EXTRACT(EPOCH FROM #{column}::timestamptz) / ?) * ?)", n_seconds, n_seconds]
             end
+          when :day, :month, :quarter, :year
+            ["DATE_TRUNC(?, #{day_start_column})::date", period, time_zone, day_start_interval]
+          else
+            # day start is always 0 for seconds, minute, hour
+            ["DATE_TRUNC(?, #{day_start_column}) AT TIME ZONE ?", period, time_zone, day_start_interval, time_zone]
           end
 
         clean_group_clause(@relation.send(:sanitize_sql_array, query))

data/lib/groupdate/adapters/sqlite_adapter.rb

@@ -2,12 +2,9 @@ module Groupdate
   module Adapters
     class SQLiteAdapter < BaseAdapter
       def group_clause
-        raise Groupdate::Error, "Time zones not supported for SQLite" unless @time_zone.utc_offset.zero?
-        raise Groupdate::Error, "day_start not supported for SQLite" unless day_start.zero?
-
         query =
           if period == :week
-            ["strftime('%Y-%m-%d 00:00:00 UTC', #{column}, '-6 days', ?)", "weekday #{(week_start + 1) % 7}"]
+            ["strftime('%Y-%m-%d', #{column}, '-6 days', ?)", "weekday #{(week_start + 1) % 7}"]
           elsif period == :custom
             ["datetime((strftime('%s', #{column}) / ?) * ?, 'unixepoch')", n_seconds, n_seconds]
           else
@@ -32,20 +29,58 @@ module Groupdate
               when :hour
                 "%Y-%m-%d %H:00:00 UTC"
               when :day
-                "%Y-%m-%d 00:00:00 UTC"
+                "%Y-%m-%d"
               when :month
-                "%Y-%m-01 00:00:00 UTC"
+                "%Y-%m-01"
               when :quarter
-                raise Groupdate::Error, "Quarter not supported for SQLite"
+                nil
               else # year
-                "%Y-01-01 00:00:00 UTC"
+                "%Y-01-01"
               end
 
             ["strftime(?, #{column})", format]
           end
 
+        if period != :custom && (@time_zone != SeriesBuilder.utc || day_start != 0 || period == :quarter)
+          setup_function
+          week_start = period == :week ? Groupdate::Magic::DAYS[self.week_start].to_s : nil
+          query = ["groupdate_internal(?, #{column}, ?, ?, ?)", period, @time_zone.tzinfo.name, day_start, week_start]
+        end
+
         @relation.send(:sanitize_sql_array, query)
       end
+
+      private
+
+      def setup_function
+        @relation.connection_pool.with_connection do |connection|
+          raw_connection = connection.raw_connection
+          return if raw_connection.instance_variable_defined?(:@groupdate_function)
+
+          utc = SeriesBuilder.utc
+          date_periods = %i[day week month quarter year]
+
+          # note: this function is part of the internal API and may change between releases
+          # TODO improve performance
+          raw_connection.create_function("groupdate_internal", 4) do |func, period, value, time_zone, day_start, week_start|
+            if value.nil?
+              func.result = nil
+            else
+              period = period.to_sym
+              # cast_result handles week_start for day_of_week
+              week_start = :sunday if period == :day_of_week
+              result = SeriesBuilder.round_time(utc.parse(value), period, ActiveSupport::TimeZone[time_zone], day_start.to_i, week_start&.to_sym)
+              if date_periods.include?(period)
+                result = result.strftime("%Y-%m-%d")
+              elsif result.is_a?(Time)
+                result = result.in_time_zone(utc).strftime("%Y-%m-%d %H:%M:%S")
+              end
+              func.result = result
+            end
+          end
+          raw_connection.instance_variable_set(:@groupdate_function, true)
+        end
+      end
     end
   end
 end

data/lib/groupdate/enumerable.rb

@@ -5,7 +5,7 @@ module Enumerable
         raise ArgumentError, "wrong number of arguments (given #{args.size}, expected 0)" if args.any?
         Groupdate::Magic::Enumerable.group_by(self, period, options, &block)
       elsif respond_to?(:scoping)
-        scoping { @klass.group_by_period(period, *args, **options, &block) }
+        scoping { klass.group_by_period(period, *args, **options, &block) }
       else
         raise ArgumentError, "no block given"
       end
@@ -19,7 +19,7 @@ module Enumerable
       Groupdate::Magic.validate_period(period, options.delete(:permit))
       send("group_by_#{period}", **options, &block)
     else
-      scoping { @klass.group_by_period(period, *args, **options, &block) }
+      scoping { klass.group_by_period(period, *args, **options, &block) }
     end
   end
 end

data/lib/groupdate/magic.rb

@@ -22,7 +22,7 @@ module Groupdate
     end
 
     def validate_keywords
-      known_keywords = [:time_zone, :dates, :series, :format, :locale, :range, :reverse]
+      known_keywords = [:time_zone, :series, :format, :locale, :range, :expand_range, :reverse]
 
       if %i[week day_of_week].include?(period)
         known_keywords << :week_start
@@ -125,6 +125,10 @@ module Groupdate
       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)
@@ -145,6 +149,16 @@ module Groupdate
             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) }
@@ -166,12 +180,13 @@ module Groupdate
       end
 
       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
+        relation.connection_pool.with_connection do |connection|
+          if connection.adapter_name.match?(/mysql|trilogy/i)
+            sql = relation.send(:sanitize_sql_array, ["SELECT CONVERT_TZ(NOW(), '+00:00', ?)", time_zone.tzinfo.name])
+            !connection.select_all(sql).to_a.first.values.first.nil?
+          else
+            true
+          end
         end
       end
 
@@ -189,21 +204,26 @@ module Groupdate
       def self.generate_relation(relation, field:, **options)
         magic = Groupdate::Magic::Relation.new(**options)
 
-        adapter_name = relation.connection.adapter_name
+        adapter_name = relation.connection_pool.with_connection { |c| c.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: field,
+            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
+            n_seconds: magic.n_seconds,
+            adapter_name: adapter_name
           ).generate
 
         # add Groupdate info
@@ -213,9 +233,33 @@ module Groupdate
         relation
       end
 
+      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
+
+        # 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_pool.with_connection { |c| c.visitor.accept(node, Arel::Collectors::SQLString.new).value }
+        end
+      end
+
       # allow any options to keep flexible for future
       def self.process_result(relation, result, **options)
-        relation.groupdate_values.reverse.each do |gv|
+        relation.groupdate_values.reverse_each do |gv|
           result = gv.perform(relation, result, default_value: options[:default_value])
         end
         result

data/lib/groupdate/relation.rb

@@ -9,6 +9,9 @@ module Groupdate
     end
 
     def calculate(*args, &block)
+      # prevent calculate from being called twice
+      return super if has_include?(args[1])
+
       default_value = [:count, :sum].include?(args[0]) ? 0 : nil
       Groupdate.process_result(self, super, default_value: default_value)
     end

data/lib/groupdate/series_builder.rb

@@ -2,8 +2,6 @@ module Groupdate
   class SeriesBuilder
     attr_reader :period, :time_zone, :day_start, :week_start, :n_seconds, :options
 
-    CHECK_PERIODS = [:day, :week, :month, :quarter, :year]
-
     def initialize(period:, time_zone:, day_start:, week_start:, n_seconds:, **options)
       @period = period
       @time_zone = time_zone
@@ -23,41 +21,12 @@ module Groupdate
         verified_data[k] = data.delete(k)
       end
 
-      # this is a fun one
-      # PostgreSQL and Ruby both return the 2nd hour when converting/parsing a backward DST change
-      # Other databases and Active Support return the 1st hour (as expected)
-      # Active Support good: ActiveSupport::TimeZone["America/Los_Angeles"].parse("2013-11-03 01:00:00")
-      # MySQL good: SELECT CONVERT_TZ('2013-11-03 01:00:00', 'America/Los_Angeles', 'Etc/UTC');
-      # Ruby not good: Time.parse("2013-11-03 01:00:00")
-      # PostgreSQL not good: SELECT '2013-11-03 01:00:00'::timestamp AT TIME ZONE 'America/Los_Angeles';
-      # we need to account for this here
-      if series_default && CHECK_PERIODS.include?(period)
-        data.each do |k, v|
-          key = multiple_groups ? k[group_index] : k
-          # TODO only do this for PostgreSQL
-          # this may mask some inconsistent time zone errors
-          # but not sure there's a better approach
-          if key.hour == (key - 1.hour).hour && series.include?(key - 1.hour)
-            key -= 1.hour
-            if multiple_groups
-              k[group_index]  = key
-            else
-              k = key
-            end
-            verified_data[k] = v
-          elsif key != round_time(key)
-            # only need to show what database returned since it will cast in Ruby time zone
-            raise Groupdate::Error, "Database and Ruby have inconsistent time zone info. Database returned #{key}"
-          end
-        end
-      end
-
       unless entire_series?(series_default)
         series = series.select { |k| verified_data[k] }
       end
 
       value = 0
-      result = Hash[series.map do |k|
+      result = series.to_h do |k|
         value = verified_data[k] || (@options[:carry_forward] && value) || default_value
         key =
           if multiple_groups
@@ -67,7 +36,7 @@ module Groupdate
           end
 
         [key, value]
-      end]
+      end
 
       result
     end
@@ -77,11 +46,16 @@ module Groupdate
         return time_zone.at((time.to_time.to_i / n_seconds) * n_seconds)
       end
 
-      time = time.to_time.in_time_zone(time_zone)
+      # TODO avoid calling to_time on dates
+      self.class.round_time(time.to_time, period, time_zone, day_start, @week_start_key)
+    end
+
+    def self.round_time(time, period, time_zone, day_start, week_start_key)
+      time = time.in_time_zone(time_zone)
 
       if day_start != 0
         # apply day_start to a time object that's not affected by DST
-        time = change_zone.call(time, utc)
+        time = time.change(zone: utc)
         time -= day_start.seconds
       end
 
@@ -96,7 +70,7 @@ module Groupdate
         when :day
           time.beginning_of_day
         when :week
-          time.beginning_of_week(@week_start_key)
+          time.beginning_of_week(week_start_key)
         when :month
           time.beginning_of_month
         when :quarter
@@ -108,7 +82,7 @@ module Groupdate
         when :minute_of_hour
           time.min
         when :day_of_week
-          time.days_to_week_start(@week_start_key)
+          time.days_to_week_start(week_start_key)
         when :day_of_month
           time.day
         when :month_of_year
@@ -121,23 +95,12 @@ module Groupdate
 
       if day_start != 0 && time.is_a?(Time)
         time += day_start.seconds
-        time = change_zone.call(time, time_zone)
+        time = time.change(zone: time_zone)
       end
 
       time
     end
 
-    def change_zone
-      @change_zone ||= begin
-        if ActiveSupport::VERSION::STRING >= "5.2"
-          ->(time, zone) { time.change(zone: zone) }
-        else
-          # TODO make more efficient
-          ->(time, zone) { zone.parse(time.strftime("%Y-%m-%d %H:%M:%S")) }
-        end
-      end
-    end
-
     def time_range
       @time_range ||= begin
         time_range = options[:range]
@@ -148,10 +111,6 @@ module Groupdate
             case v
             when nil, Date, Time
               # good
-            when String
-              # TODO raise error in Groupdate 6
-              warn "[groupdate] Range bounds should be Date or Time, not #{v.class.name}. This will raise an error in Groupdate 6"
-              break
             else
               raise ArgumentError, "Range bounds should be Date or Time, not #{v.class.name}"
             end
@@ -164,37 +123,37 @@ module Groupdate
 
           finish = time_range.end
           finish = finish.in_time_zone(time_zone) if finish
-          if time_range.end.is_a?(Date) && !exclude_end
+          if time_range.end.is_a?(Date) && !time_range.end.is_a?(DateTime) && !exclude_end
             finish += 1.day
             exclude_end = true
           end
 
+          if options[:expand_range]
+            start = round_time(start) if start
+            if finish && !(finish == round_time(finish) && exclude_end)
+              finish = round_time(finish) + step
+              exclude_end = true
+            end
+          end
+
           time_range = Range.new(start, finish, exclude_end)
         elsif !time_range && options[:last]
-          if period == :quarter
-            step = 3.months
-          elsif period == :custom
-            step = n_seconds
-          elsif 1.respond_to?(period)
-            step = 1.send(period)
-          else
-            raise ArgumentError, "Cannot use last option with #{period}"
-          end
-          if step
-            # loop instead of multiply to change start_at - see #151
-            start_at = now
-            (options[:last].to_i - 1).times do
-              start_at -= step
-            end
+          step = step()
+          raise ArgumentError, "Cannot use last option with #{period}" unless step
 
-            time_range =
-              if options[:current] == false
-                round_time(start_at - step)...round_time(now)
-              else
-                # extend to end of current period
-                round_time(start_at)...(round_time(now) + step)
-              end
+          # 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
+              # extend to end of current period
+              round_time(start_at)...(round_time(now) + step)
+            end
         end
         time_range
       end
@@ -256,13 +215,7 @@ module Groupdate
         if time_range.begin
           series = [round_time(time_range.begin)]
 
-          if period == :quarter
-            step = 3.months
-          elsif period == :custom
-            step = n_seconds
-          else
-            step = 1.send(period)
-          end
+          step = step()
 
           last_step = series.last
           day_start_hour = day_start / 3600
@@ -289,7 +242,6 @@ module Groupdate
     def key_format
       @key_format ||= begin
         locale = options[:locale] || I18n.locale
-        use_dates = options.key?(:dates) ? options[:dates] : Groupdate.dates
 
         if options[:format]
           if options[:format].respond_to?(:call)
@@ -312,7 +264,7 @@ module Groupdate
               I18n.localize(key, format: options[:format], locale: locale)
             end
           end
-        elsif [:day, :week, :month, :quarter, :year].include?(period) && use_dates
+        elsif [:day, :week, :month, :quarter, :year].include?(period)
           lambda { |k| k.to_date }
         else
           lambda { |k| k }
@@ -320,6 +272,16 @@ module Groupdate
       end
     end
 
+    def step
+      if period == :quarter
+        3.months
+      elsif period == :custom
+        n_seconds
+      elsif 1.respond_to?(period)
+        1.send(period)
+      end
+    end
+
     def handle_multiple(data, series, multiple_groups, group_index)
       reverse = options[:reverse]
 
@@ -340,7 +302,7 @@ module Groupdate
       options.key?(:series) ? options[:series] : series_default
     end
 
-    def utc
+    def self.utc
       @utc ||= ActiveSupport::TimeZone["Etc/UTC"]
     end
   end

data/lib/groupdate/version.rb

@@ -1,3 +1,3 @@
 module Groupdate
-  VERSION = "5.2.4"
+  VERSION = "6.8.0"
 end

data/lib/groupdate.rb

@@ -4,16 +4,15 @@ require "active_support/core_ext/module/attribute_accessors"
 require "active_support/time"
 
 # modules
-require "groupdate/magic"
-require "groupdate/series_builder"
-require "groupdate/version"
+require_relative "groupdate/magic"
+require_relative "groupdate/series_builder"
+require_relative "groupdate/version"
 
 # adapters
-require "groupdate/adapters/base_adapter"
-require "groupdate/adapters/mysql_adapter"
-require "groupdate/adapters/postgresql_adapter"
-require "groupdate/adapters/redshift_adapter"
-require "groupdate/adapters/sqlite_adapter"
+require_relative "groupdate/adapters/base_adapter"
+require_relative "groupdate/adapters/mysql_adapter"
+require_relative "groupdate/adapters/postgresql_adapter"
+require_relative "groupdate/adapters/sqlite_adapter"
 
 module Groupdate
   class Error < RuntimeError; end
@@ -21,10 +20,9 @@ module Groupdate
   PERIODS = [:second, :minute, :hour, :day, :week, :month, :quarter, :year, :day_of_week, :hour_of_day, :minute_of_hour, :day_of_month, :day_of_year, :month_of_year]
   METHODS = PERIODS.map { |v| :"group_by_#{v}" } + [:group_by_period]
 
-  mattr_accessor :week_start, :day_start, :time_zone, :dates
+  mattr_accessor :week_start, :day_start, :time_zone
   self.week_start = :sunday
   self.day_start = 0
-  self.dates = true
 
   # api for gems like ActiveMedian
   def self.process_result(relation, result, **options)
@@ -45,13 +43,12 @@ module Groupdate
   end
 end
 
-Groupdate.register_adapter ["Mysql2", "Mysql2Spatial", "Mysql2Rgeo"], Groupdate::Adapters::MySQLAdapter
-Groupdate.register_adapter ["PostgreSQL", "PostGIS"], Groupdate::Adapters::PostgreSQLAdapter
-Groupdate.register_adapter "Redshift", Groupdate::Adapters::RedshiftAdapter
+Groupdate.register_adapter ["Mysql2", "Mysql2Spatial", "Mysql2Rgeo", "Trilogy"], Groupdate::Adapters::MySQLAdapter
+Groupdate.register_adapter ["PostgreSQL", "PostGIS", "Redshift"], Groupdate::Adapters::PostgreSQLAdapter
 Groupdate.register_adapter "SQLite", Groupdate::Adapters::SQLiteAdapter
 
-require "groupdate/enumerable"
+require_relative "groupdate/enumerable"
 
 ActiveSupport.on_load(:active_record) do
-  require "groupdate/active_record"
+  require_relative "groupdate/active_record"
 end

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: groupdate
 version: !ruby/object:Gem::Version
-  version: 5.2.4
+  version: 6.8.0
 platform: ruby
 authors:
 - Andrew Kane
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-12-16 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -16,15 +15,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '5'
+        version: '7.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '5'
-description:
+        version: '7.2'
 email: andrew@ankane.org
 executables: []
 extensions: []
@@ -39,7 +37,6 @@ files:
 - lib/groupdate/adapters/base_adapter.rb
 - lib/groupdate/adapters/mysql_adapter.rb
 - lib/groupdate/adapters/postgresql_adapter.rb
-- lib/groupdate/adapters/redshift_adapter.rb
 - lib/groupdate/adapters/sqlite_adapter.rb
 - lib/groupdate/enumerable.rb
 - lib/groupdate/magic.rb
@@ -51,7 +48,6 @@ homepage: https://github.com/ankane/groupdate
 licenses:
 - MIT
 metadata: {}
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -59,15 +55,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.4'
+      version: '3.3'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.32
-signing_key:
+rubygems_version: 4.0.6
 specification_version: 4
 summary: The simplest way to group temporal data
 test_files: []

data/lib/groupdate/adapters/redshift_adapter.rb

@@ -1,39 +0,0 @@
-module Groupdate
-  module Adapters
-    class RedshiftAdapter < BaseAdapter
-      def group_clause
-        time_zone = @time_zone.tzinfo.name
-        day_start_column = "CONVERT_TIMEZONE(?, #{column}::timestamp) - INTERVAL ?"
-        day_start_interval = "#{day_start} second"
-
-        query =
-          case period
-          when :minute_of_hour
-            ["EXTRACT(MINUTE from #{day_start_column})::integer", time_zone, day_start_interval]
-          when :hour_of_day
-            ["EXTRACT(HOUR from #{day_start_column})::integer", time_zone, day_start_interval]
-          when :day_of_week
-            ["EXTRACT(DOW from #{day_start_column})::integer", time_zone, day_start_interval]
-          when :day_of_month
-            ["EXTRACT(DAY from #{day_start_column})::integer", time_zone, day_start_interval]
-          when :day_of_year
-            ["EXTRACT(DOY from #{day_start_column})::integer", time_zone, day_start_interval]
-          when :month_of_year
-            ["EXTRACT(MONTH from #{day_start_column})::integer", time_zone, day_start_interval]
-          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.
-            week_start_interval = "#{week_start} day"
-            ["CONVERT_TIMEZONE(?, 'Etc/UTC', DATE_TRUNC('week', #{day_start_column} - INTERVAL ?) + INTERVAL ? + INTERVAL ?)::timestamp", time_zone, time_zone, day_start_interval, week_start_interval, week_start_interval, day_start_interval]
-          when :custom
-            raise Groupdate::Error, "Not implemented yet"
-          else
-            ["CONVERT_TIMEZONE(?, 'Etc/UTC', DATE_TRUNC(?, #{day_start_column}) + INTERVAL ?)::timestamp", time_zone, period, time_zone, day_start_interval, day_start_interval]
-          end
-
-        @relation.send(:sanitize_sql_array, query)
-      end
-    end
-  end
-end