sequel 4.36.0 → 5.61.0

data/lib/sequel/extensions/core_refinements.rb

@@ -10,15 +10,23 @@
 #
 #   using Sequel::CoreRefinements
 
+# :nocov:
 raise(Sequel::Error, "Refinements require ruby 2.0.0 or greater") unless RUBY_VERSION >= '2.0.0'
+# :nocov:
 
 module Sequel::CoreRefinements
+  # :nocov:
+  include_meth = RUBY_VERSION >= '3.1' ? :import_methods : :include
+  # :nocov:
+  INCLUDE_METH = include_meth
+  private_constant :INCLUDE_METH
+
   refine Array do
     # Return a <tt>Sequel::SQL::BooleanExpression</tt> created from this array, not matching all of the
     # conditions.
     #
-    #   ~[[:a, true]] # SQL: a IS NOT TRUE
-    #   ~[[:a, 1], [:b, [2, 3]]] # SQL: a != 1 OR b NOT IN (2, 3)
+    #   ~[[:a, true]] # SQL: (a IS NOT TRUE)
+    #   ~[[:a, 1], [:b, [2, 3]]] # SQL: ((a != 1) OR (b NOT IN (2, 3)))
     def ~
       Sequel.~(self)
     end
@@ -26,7 +34,7 @@ module Sequel::CoreRefinements
     # Return a <tt>Sequel::SQL::CaseExpression</tt> with this array as the conditions and the given
     # default value and expression.
     #
-    #   [[{:a=>[2,3]}, 1]].case(0) # SQL: CASE WHEN a IN (2, 3) THEN 1 ELSE 0 END
+    #   [[{a: [2,3]}, 1]].case(0) # SQL: CASE WHEN (a IN (2, 3)) THEN 1 ELSE 0 END
     #   [[:a, 1], [:b, 2]].case(:d, :c) # SQL: CASE c WHEN a THEN 1 WHEN b THEN 2 ELSE d END
     def case(*args)
       ::Sequel::SQL::CaseExpression.new(self, *args)
@@ -38,9 +46,9 @@ module Sequel::CoreRefinements
     # this array as a value in a filter, but may be necessary if you are using it as a
     # value with placeholder SQL:
     #
-    #   DB[:a].filter([:a, :b]=>[[1, 2], [3, 4]]) # SQL: (a, b) IN ((1, 2), (3, 4))
-    #   DB[:a].filter('(a, b) IN ?', [[1, 2], [3, 4]]) # SQL: (a, b) IN ((1 = 2) AND (3 = 4))
-    #   DB[:a].filter('(a, b) IN ?', [[1, 2], [3, 4]].sql_value_list) # SQL: (a, b) IN ((1, 2), (3, 4))
+    #   DB[:a].where([:a, :b]=>[[1, 2], [3, 4]]) # SQL: ((a, b) IN ((1, 2), (3, 4)))
+    #   DB[:a].where('(a, b) IN ?', [[1, 2], [3, 4]]) # SQL: ((a, b) IN ((1 = 2) AND (3 = 4)))
+    #   DB[:a].where('(a, b) IN ?', [[1, 2], [3, 4]].sql_value_list) # SQL: ((a, b) IN ((1, 2), (3, 4)))
     def sql_value_list
       ::Sequel::SQL::ValueList.new(self)
     end
@@ -52,17 +60,17 @@ module Sequel::CoreRefinements
     # and want to use the = operator instead of the IN operator (which is used by default for
     # arrays of two element arrays).
     #
-    #   [[:a, true]].sql_expr # SQL: a IS TRUE
-    #   [[:a, 1], [:b, [2, 3]]].sql_expr # SQL: a = 1 AND b IN (2, 3)
+    #   [[:a, true]].sql_expr # SQL: (a IS TRUE)
+    #   [[:a, 1], [:b, [2, 3]]].sql_expr # SQL: ((a = 1) AND (b IN (2, 3)))
     def sql_expr
-      Sequel.expr(self)
+      Sequel[self]
     end
 
     # Return a <tt>Sequel::SQL::BooleanExpression</tt> created from this array, matching none
     # of the conditions.
     #
-    #   [[:a, true]].sql_negate # SQL: a IS NOT TRUE
-    #   [[:a, 1], [:b, [2, 3]]].sql_negate # SQL: a != 1 AND b NOT IN (2, 3)
+    #   [[:a, true]].sql_negate # SQL: (a IS NOT TRUE)
+    #   [[:a, 1], [:b, [2, 3]]].sql_negate # SQL: ((a != 1) AND (b NOT IN (2, 3)))
     def sql_negate
       Sequel.negate(self)
     end
@@ -70,8 +78,8 @@ module Sequel::CoreRefinements
     # Return a <tt>Sequel::SQL::BooleanExpression</tt> created from this array, matching any of the
     # conditions.
     #
-    #   [[:a, true]].sql_or # SQL: a IS TRUE
-    #   [[:a, 1], [:b, [2, 3]]].sql_or # SQL: a = 1 OR b IN (2, 3)
+    #   [[:a, true]].sql_or # SQL: (a IS TRUE)
+    #   [[:a, 1], [:b, [2, 3]]].sql_or # SQL: ((a = 1) OR (b IN (2, 3)))
     def sql_or
       Sequel.or(self)
     end
@@ -82,9 +90,9 @@ module Sequel::CoreRefinements
     # concatenation.
     #
     #   [:a].sql_string_join # SQL: a
-    #   [:a, :b].sql_string_join # SQL: a || b
-    #   [:a, 'b'].sql_string_join # SQL: a || 'b'
-    #   ['a', :b].sql_string_join(' ') # SQL: 'a' || ' ' || b
+    #   [:a, :b].sql_string_join # SQL: (a || b)
+    #   [:a, 'b'].sql_string_join # SQL: (a || 'b')
+    #   ['a', :b].sql_string_join(' ') # SQL: ('a' || ' ' || b)
     def sql_string_join(joiner=nil)
       Sequel.join(self, joiner)
     end
@@ -95,8 +103,8 @@ module Sequel::CoreRefinements
     # all of the conditions in this hash and the condition specified by
     # the given argument.
     #
-    #   {:a=>1} & :b # SQL: a = 1 AND b
-    #   {:a=>true} & ~:b # SQL: a IS TRUE AND NOT b
+    #   {a: 1} & :b # SQL: ((a = 1) AND b)
+    #   {a: true} & ~:b # SQL: ((a IS TRUE) AND NOT b)
     def &(ce)
       ::Sequel::SQL::BooleanExpression.new(:AND, self, ce)
     end
@@ -105,8 +113,8 @@ module Sequel::CoreRefinements
     # all of the conditions in this hash or the condition specified by
     # the given argument.
     #
-    #   {:a=>1} | :b # SQL: a = 1 OR b
-    #   {:a=>true} | ~:b # SQL: a IS TRUE OR NOT b
+    #   {a: 1} | :b # SQL: ((a = 1) OR b)
+    #   {a: true} | ~:b # SQL: ((a IS TRUE) OR NOT b)
     def |(ce)
       ::Sequel::SQL::BooleanExpression.new(:OR, self, ce)
     end
@@ -114,19 +122,17 @@ module Sequel::CoreRefinements
     # Return a <tt>Sequel::SQL::BooleanExpression</tt> created from this hash, not matching all of the
     # conditions.
     #
-    #   ~{:a=>true} # SQL: a IS NOT TRUE
-    #   ~{:a=>1, :b=>[2, 3]} # SQL: a != 1 OR b NOT IN (2, 3)
+    #   ~{a: true} # SQL: (a IS NOT TRUE)
+    #   ~{a: 1, b: [2, 3]} # SQL: ((a != 1) OR (b NOT IN (2, 3)))
     def ~
       ::Sequel::SQL::BooleanExpression.from_value_pairs(self, :OR, true)
     end
 
     # Return a <tt>Sequel::SQL::CaseExpression</tt> with this hash as the conditions and the given
-    # default value.  Note that the order of the conditions will be arbitrary on ruby 1.8, so all
-    # conditions should be orthogonal.
+    # default value.
     #
-    #   {{:a=>[2,3]}=>1}.case(0) # SQL: CASE WHEN a IN (2, 3) THEN 1 ELSE 0 END
-    #   {:a=>1, :b=>2}.case(:d, :c) # SQL: CASE c WHEN a THEN 1 WHEN b THEN 2 ELSE d END
-    #                                 #  or: CASE c WHEN b THEN 2 WHEN a THEN 1 ELSE d END
+    #   {{a: [2,3]}=>1}.case(0) # SQL: CASE WHEN (a IN (2, 3)) THEN 1 ELSE 0 END
+    #   {a: 1, b: 2}.case(:d, :c) # SQL: CASE c WHEN a THEN 1 WHEN b THEN 2 ELSE d END
     def case(*args)
       ::Sequel::SQL::CaseExpression.new(to_a, *args)
     end
@@ -135,8 +141,8 @@ module Sequel::CoreRefinements
     # conditions.  Rarely do you need to call this explicitly, as Sequel generally
     # assumes that hashes specify this type of condition.
     #
-    #   {:a=>true}.sql_expr # SQL: a IS TRUE
-    #   {:a=>1, :b=>[2, 3]}.sql_expr # SQL: a = 1 AND b IN (2, 3)
+    #   {a: true}.sql_expr # SQL: (a IS TRUE)
+    #   {a: 1, b: [2, 3]}.sql_expr # SQL: ((a = 1) AND (b IN (2, 3)))
     def sql_expr
       ::Sequel::SQL::BooleanExpression.from_value_pairs(self)
     end
@@ -144,8 +150,8 @@ module Sequel::CoreRefinements
     # Return a <tt>Sequel::SQL::BooleanExpression</tt> created from this hash, matching none
     # of the conditions.
     #
-    #   {:a=>true}.sql_negate # SQL: a IS NOT TRUE
-    #   {:a=>1, :b=>[2, 3]}.sql_negate # SQL: a != 1 AND b NOT IN (2, 3)
+    #   {a: true}.sql_negate # SQL: (a IS NOT TRUE)
+    #   {a: 1, b: [2, 3]}.sql_negate # SQL: ((a != 1) AND (b NOT IN (2, 3)))
     def sql_negate
       ::Sequel::SQL::BooleanExpression.from_value_pairs(self, :AND, true)
     end
@@ -153,30 +159,30 @@ module Sequel::CoreRefinements
     # Return a <tt>Sequel::SQL::BooleanExpression</tt> created from this hash, matching any of the
     # conditions.
     #
-    #   {:a=>true}.sql_or # SQL: a IS TRUE
-    #   {:a=>1, :b=>[2, 3]}.sql_or # SQL: a = 1 OR b IN (2, 3)
+    #   {a: true}.sql_or # SQL: (a IS TRUE)
+    #   {a: 1, b: [2, 3]}.sql_or # SQL: ((a = 1) OR (b IN (2, 3)))
     def sql_or
       ::Sequel::SQL::BooleanExpression.from_value_pairs(self, :OR)
     end
   end
 
   refine String do
-    include Sequel::SQL::AliasMethods
-    include Sequel::SQL::CastMethods
+    send include_meth, Sequel::SQL::AliasMethods
+    send include_meth, Sequel::SQL::CastMethods
 
     # Converts a string into a <tt>Sequel::LiteralString</tt>, in order to override string
     # literalization, e.g.:
     #
-    #   DB[:items].filter(:abc => 'def').sql #=>
-    #     "SELECT * FROM items WHERE (abc = 'def')"
+    #   DB[:items].where(abc: 'def')
+    #   # "SELECT * FROM items WHERE (abc = 'def')"
     #
-    #   DB[:items].filter(:abc => 'def'.lit).sql #=>
-    #     "SELECT * FROM items WHERE (abc = def)"
+    #   DB[:items].where(abc: 'def'.lit)
+    #   # "SELECT * FROM items WHERE (abc = def)"
     #
     # You can also provide arguments, to create a <tt>Sequel::SQL::PlaceholderLiteralString</tt>:
     #
-    #    DB[:items].select{|o| o.count('DISTINCT ?'.lit(:a))}.sql #=>
-    #      "SELECT count(DISTINCT a) FROM items"
+    #   DB[:items].select{|o| o.count('DISTINCT ?'.lit(:a))}
+    #   # "SELECT count(DISTINCT a) FROM items"
     def lit(*args)
       args.empty? ? Sequel::LiteralString.new(self) : Sequel::SQL::PlaceholderLiteralString.new(self, args)
     end
@@ -189,29 +195,44 @@ module Sequel::CoreRefinements
   end
 
   refine Symbol do
-    include Sequel::SQL::AliasMethods
-    include Sequel::SQL::CastMethods
-    include Sequel::SQL::OrderMethods
-    include Sequel::SQL::BooleanMethods
-    include Sequel::SQL::NumericMethods
-    include Sequel::SQL::QualifyingMethods
-    include Sequel::SQL::StringMethods
-    include Sequel::SQL::SubscriptMethods
-    include Sequel::SQL::ComplexExpressionMethods
-
-    # Returns receiver wrapped in an <tt>Sequel::SQL::Identifier</tt>.  Usually used to
-    # prevent splitting the symbol.
-    #
-    #   :a__b # SQL: "a"."b"
-    #   :a__b.identifier # SQL: "a__b"
+    send include_meth, Sequel::SQL::AliasMethods
+    send include_meth, Sequel::SQL::CastMethods
+    send include_meth, Sequel::SQL::OrderMethods
+    send include_meth, Sequel::SQL::BooleanMethods
+    send include_meth, Sequel::SQL::NumericMethods
+
+    # :nocov:
+    remove_method :* if RUBY_VERSION >= '3.1'
+    # :nocov:
+
+    send include_meth, Sequel::SQL::QualifyingMethods
+    send include_meth, Sequel::SQL::StringMethods
+    send include_meth, Sequel::SQL::SubscriptMethods
+    send include_meth, Sequel::SQL::ComplexExpressionMethods
+
+    # :nocov:
+    if RUBY_VERSION >= '3.1'
+      remove_method :*
+      def *(ce=(arg=false;nil))
+        if arg == false
+          Sequel::SQL::ColumnAll.new(self)
+        else
+          Sequel::SQL::NumericExpression.new(:*, self, ce)
+        end
+      end
+
+    end
+    # :nocov:
+
+    # Returns receiver wrapped in an <tt>Sequel::SQL::Identifier</tt>.
+    #
+    #   :ab.identifier # SQL: "a"
     def identifier
       Sequel::SQL::Identifier.new(self)
     end
 
     # Returns a <tt>Sequel::SQL::Function</tt> with this as the function name,
-    # and the given arguments. This is aliased as <tt>Symbol#[]</tt> if the RUBY_VERSION
-    # is less than 1.9.0. Ruby 1.9 defines <tt>Symbol#[]</tt>, and Sequel
-    # doesn't override methods defined by ruby itself.
+    # and the given arguments.
     #
     #   :now.sql_function # SQL: now()
     #   :sum.sql_function(:a) # SQL: sum(a)

data/lib/sequel/extensions/current_datetime_timestamp.rb

@@ -32,7 +32,7 @@ module Sequel
       # Return an instance of Sequel.datetime_class that will be literalized
       # as CURRENT_TIMESTAMP.
       def current_datetime
-        MAP.fetch(Sequel.datetime_class).now
+        (Sequel.datetime_class == ::Time ? Time : DateTime).now
       end
 
       private
@@ -53,9 +53,6 @@ module Sequel
 
     # DateTime subclass literalized as CURRENT_TIMESTAMP
     class DateTime < ::DateTime; end
-
-    # Mapping of Time/DateTime classes to subclasses literalized as CURRENT_TIMESTAMP
-    MAP = {::Time=>Time, ::DateTime=>DateTime}
   end
 
   Dataset.register_extension(:current_datetime_timestamp, CurrentDateTimeTimestamp::DatasetMethods)

data/lib/sequel/extensions/date_arithmetic.rb

@@ -8,10 +8,11 @@
 #   DB.extension :date_arithmetic
 #
 # Then you can use the Sequel.date_add and Sequel.date_sub methods
-# to return Sequel expressions:
+# to return Sequel expressions (this example shows the only supported
+# keys for the second argument):
 #
-#   add = Sequel.date_add(:date_column, :years=>1, :months=>2, :days=>3)
-#   sub = Sequel.date_sub(:date_column, :hours=>1, :minutes=>2, :seconds=>3)
+#   add = Sequel.date_add(:date_column, years: 1, months: 2, weeks: 2, days: 1)
+#   sub = Sequel.date_sub(:date_column, hours: 1, minutes: 2, seconds: 3)
 #
 # In addition to specifying the interval as a hash, there is also
 # support for specifying the interval as an ActiveSupport::Duration
@@ -21,11 +22,20 @@
 #   add = Sequel.date_add(:date_column, 1.years + 2.months + 3.days)
 #   sub = Sequel.date_sub(:date_column, 1.hours + 2.minutes + 3.seconds)
 #
+# By default, values are casted to the generic timestamp type for the
+# database.  You can override the cast type using the :cast option:
+#
+#   add = Sequel.date_add(:date_column, {years: 1, months: 2, days: 3}, :cast=>:timestamptz)
+#
 # These expressions can be used in your datasets, or anywhere else that
 # Sequel expressions are allowed:
 #
 #   DB[:table].select(add.as(:d)).where(sub > Sequel::CURRENT_TIMESTAMP)
 #
+# On most databases, the values you provide for years/months/days/etc. must
+# be numeric values and not arbitrary SQL expressions.  However, on PostgreSQL
+# 9.4+, use of arbitrary SQL expressions is supported.
+#
 # Related module: Sequel::SQL::DateAdd
 
 #
@@ -33,21 +43,32 @@ module Sequel
   module SQL
     module Builders
       # Return a DateAdd expression, adding an interval to the date/timestamp expr.
-      def date_add(expr, interval)
-        DateAdd.new(expr, interval)
+      # Options:
+      # :cast :: Cast to the specified type instead of the default if casting
+      def date_add(expr, interval, opts=OPTS)
+        DateAdd.new(expr, interval, opts)
       end
 
       # Return a DateAdd expression, adding the negative of the interval to
       # the date/timestamp expr.
-      def date_sub(expr, interval)
-        interval = if interval.is_a?(Hash)
-          h = {}
-          interval.each{|k,v| h[k] = -v unless v.nil?}
-          h
-        else
-          -interval
+      # Options:
+      # :cast :: Cast to the specified type instead of the default if casting
+      def date_sub(expr, interval, opts=OPTS)
+        if defined?(ActiveSupport::Duration) && interval.is_a?(ActiveSupport::Duration)
+          interval = interval.parts
+        end
+        parts = {}
+        interval.each do |k,v|
+          case v
+          when nil
+            # ignore
+          when Numeric
+            parts[k] = -v
+          else
+            parts[k] = Sequel::SQL::NumericExpression.new(:*, v, -1)
+          end
         end
-        DateAdd.new(expr, interval)
+        DateAdd.new(expr, parts, opts)
       end
     end
 
@@ -60,31 +81,48 @@ module Sequel
       module DatasetMethods
         DURATION_UNITS = [:years, :months, :days, :hours, :minutes, :seconds].freeze
         DEF_DURATION_UNITS = DURATION_UNITS.zip(DURATION_UNITS.map{|s| s.to_s.freeze}).freeze
+        POSTGRES_DURATION_UNITS = DURATION_UNITS.zip([:years, :months, :days, :hours, :mins, :secs].map{|s| s.to_s.freeze}).freeze
         MYSQL_DURATION_UNITS = DURATION_UNITS.zip(DURATION_UNITS.map{|s| Sequel.lit(s.to_s.upcase[0...-1]).freeze}).freeze
         MSSQL_DURATION_UNITS = DURATION_UNITS.zip(DURATION_UNITS.map{|s| Sequel.lit(s.to_s[0...-1]).freeze}).freeze
         H2_DURATION_UNITS = DURATION_UNITS.zip(DURATION_UNITS.map{|s| s.to_s[0...-1].freeze}).freeze
         DERBY_DURATION_UNITS = DURATION_UNITS.zip(DURATION_UNITS.map{|s| Sequel.lit("SQL_TSI_#{s.to_s.upcase[0...-1]}").freeze}).freeze
         ACCESS_DURATION_UNITS = DURATION_UNITS.zip(%w'yyyy m d h n s'.map(&:freeze)).freeze
         DB2_DURATION_UNITS = DURATION_UNITS.zip(DURATION_UNITS.map{|s| Sequel.lit(s.to_s).freeze}).freeze
-        FDBSQL_DURATION_UNITS = DURATION_UNITS.zip(DURATION_UNITS.map{|s| Sequel.lit(s.to_s.chop).freeze}).freeze
 
         # Append the SQL fragment for the DateAdd expression to the SQL query.
         def date_add_sql_append(sql, da)
           if defined?(super)
             return super
           end
+
           h = da.interval
           expr = da.expr
+          cast_type = da.cast_type || Time
+
           cast = case db_type = db.database_type
           when :postgres
-            interval = String.new
-            each_valid_interval_unit(h, DEF_DURATION_UNITS) do |value, sql_unit|
-              interval << "#{value} #{sql_unit} "
+            casted = Sequel.cast(expr, cast_type)
+
+            if db.server_version >= 90400
+              placeholder = []
+              vals = []
+              each_valid_interval_unit(h, POSTGRES_DURATION_UNITS) do |value, sql_unit|
+                placeholder << "#{', ' unless placeholder.empty?}#{sql_unit} := "
+                vals << value
+              end
+              interval = Sequel.function(:make_interval, Sequel.lit(placeholder, *vals)) unless vals.empty?
+            else
+              parts = String.new
+              each_valid_interval_unit(h, DEF_DURATION_UNITS) do |value, sql_unit|
+                parts << "#{value} #{sql_unit} "
+              end
+              interval = Sequel.cast(parts, :interval) unless parts.empty?
             end
-            if interval.empty?
-              return literal_append(sql, Sequel.cast(expr, Time))
+
+            if interval
+              return complex_expression_sql_append(sql, :+, [casted, interval])
             else
-              return complex_expression_sql_append(sql, :+, [Sequel.cast(expr, Time), Sequel.cast(interval, :interval)])
+              return literal_append(sql, casted)
             end
           when :sqlite
             args = [expr]
@@ -92,22 +130,22 @@ module Sequel
               args << "#{value} #{sql_unit}"
             end
             return function_sql_append(sql, Sequel.function(:datetime, *args))
-          when :mysql, :hsqldb, :cubrid
+          when :mysql, :hsqldb
             if db_type == :hsqldb
               # HSQLDB requires 2.2.9+ for the DATE_ADD function
-              expr = Sequel.cast(expr, Time)
+              expr = Sequel.cast(expr, cast_type)
             end
             each_valid_interval_unit(h, MYSQL_DURATION_UNITS) do |value, sql_unit|
               expr = Sequel.function(:DATE_ADD, expr, Sequel.lit(["INTERVAL ", " "], value, sql_unit))
             end
           when :mssql, :h2, :access, :sqlanywhere
             units = case db_type
-            when :mssql, :sqlanywhere
-              MSSQL_DURATION_UNITS
             when :h2
               H2_DURATION_UNITS
             when :access
               ACCESS_DURATION_UNITS
+            else
+              MSSQL_DURATION_UNITS
             end
             each_valid_interval_unit(h, units) do |value, sql_unit|
               expr = Sequel.function(:DATEADD, sql_unit, value, expr)
@@ -125,7 +163,7 @@ module Sequel
               expr = Sequel.+(expr, Sequel.lit(["INTERVAL ", " "], value.to_s, sql_unit))
             end
           when :db2
-            expr = Sequel.cast(expr, Time)
+            expr = Sequel.cast(expr, cast_type)
             each_valid_interval_unit(h, DB2_DURATION_UNITS) do |value, sql_unit|
               expr = Sequel.+(expr, Sequel.lit(["", " "], value, sql_unit))
             end
@@ -135,7 +173,7 @@ module Sequel
           end
 
           if cast
-            expr = Sequel.cast(expr, Time)
+            expr = Sequel.cast(expr, cast_type)
           end
 
           literal_append(sql, expr)
@@ -166,25 +204,46 @@ module Sequel
       # symbol keys.
       attr_reader :interval
 
+      # The type to cast the expression to.  nil if not overridden, in which cast
+      # the generic timestamp type for the database will be used.
+      attr_reader :cast_type
+
       # Supports two types of intervals:
       # Hash :: Used directly, but values cannot be plain strings.
       # ActiveSupport::Duration :: Converted to a hash using the interval's parts.
-      def initialize(expr, interval)
+      def initialize(expr, interval, opts=OPTS)
         @expr = expr
-        @interval = if interval.is_a?(Hash)
-          interval.each_value do |v|
-             # Attempt to prevent SQL injection by users who pass untrusted strings
-             # as interval values. 
-             if v.is_a?(String) && !v.is_a?(LiteralString)
-               raise Sequel::InvalidValue, "cannot provide String value as interval part: #{v.inspect}"
-             end
+
+        h = Hash.new(0)
+        interval = interval.parts unless interval.is_a?(Hash)
+        interval.each do |unit, value|
+          # skip nil values
+          next unless value
+
+          # Convert weeks to days, as ActiveSupport::Duration can use weeks,
+          # but the database-specific literalizers only support days.
+          if unit == :weeks
+            unit = :days
+            value *= 7
           end
-          interval
-        else
-          h = Hash.new(0)
-          interval.parts.each{|unit, value| h[unit] += value}
-          Hash[h]
+
+          unless DatasetMethods::DURATION_UNITS.include?(unit)
+            raise Sequel::Error, "Invalid key used in DateAdd interval hash: #{unit.inspect}"
+          end
+
+          # Attempt to prevent SQL injection by users who pass untrusted strings
+          # as interval values. It doesn't make sense to support literal strings,
+          # due to the numeric adding below.
+          if value.is_a?(String)
+            raise Sequel::InvalidValue, "cannot provide String value as interval part: #{value.inspect}"
+          end
+
+          h[unit] += value
         end
+
+        @interval = Hash[h].freeze
+        @cast_type = opts[:cast] if opts[:cast]
+        freeze
       end
 
       to_s_method :date_add_sql

data/lib/sequel/extensions/date_parse_input_handler.rb

@@ -0,0 +1,67 @@
+# frozen-string-literal: true
+#
+# The date_parse_input_handler extension allows for configuring how input
+# to date parsing methods should be handled.  By default, the
+# extension does not change behavior.  However, you can use the
+# +Sequel.date_parse_input_handler+ method to support custom handling
+# of input strings to the date parsing methods.  For example, if you want
+# to implement a length check to prevent denial of service vulnerabilities
+# in older versions of Ruby, you can do:
+#
+#   Sequel.extension :date_parse_input_handler
+#   Sequel.date_parse_input_handler do |string|
+#     raise Sequel::InvalidValue, "string length (200) exceeds the limit 128" if string.bytesize > 128
+#     string
+#   end
+#
+# You can also use +Sequel.date_parse_input_handler+ to modify the string
+# that will be passed to the parsing methods.  For example, you could
+# truncate it:
+#
+#   Sequel.date_parse_input_handler do |string|
+#     string.b[0, 128]
+#   end
+#
+# Be aware that modern versions of Ruby will raise an exception if
+# date parsing input exceeds 128 bytes.
+
+module Sequel
+  module DateParseInputHandler
+    def date_parse_input_handler(&block)
+      singleton_class.class_eval do
+        define_method(:handle_date_parse_input, &block)
+        private :handle_date_parse_input
+        alias handle_date_parse_input handle_date_parse_input
+      end
+    end
+
+    # Call date parse input handler with input string.
+    def string_to_date(string)
+      super(handle_date_parse_input(string))
+    end
+
+    # Call date parse input handler with input string.
+    def string_to_datetime(string)
+      super(handle_date_parse_input(string))
+    end
+
+    # Call date parse input handler with input string.
+    def string_to_time(string)
+      super(handle_date_parse_input(string))
+    end
+
+    private
+
+    # Call date parse input handler with input string.
+    def _date_parse(string)
+      super(handle_date_parse_input(string))
+    end
+
+    # Return string as-is by default, so by default behavior does not change.
+    def handle_date_parse_input(string)
+      string
+    end
+  end
+
+  extend DateParseInputHandler
+end

data/lib/sequel/extensions/datetime_parse_to_time.rb

@@ -0,0 +1,41 @@
+# frozen-string-literal: true
+#
+# This switches the default parsing of strings into Time values
+# from using Time.parse to using DateTime.parse.to_time.  This
+# fixes issues when the times being parsed have no timezone
+# information, the implicit timezone for the Database instance
+# is set to +:utc+, and the timestamps being used include values
+# not valid in the local timezone, such as during a daylight
+# savings time switch.  
+#
+# To load the extension:
+#
+#   Sequel.extension :datetime_parse_to_time
+
+#
+module Sequel::DateTimeParseToTime
+  private
+
+  # Use DateTime.parse.to_time to do the conversion if the input a string and is assumed to
+  # be in UTC and there is no offset information in the string.
+  def convert_input_timestamp(v, input_timezone)
+    if v.is_a?(String) && datetime_class == Time && input_timezone == :utc && !_date_parse(v).has_key?(:offset)
+      # :nocov:
+      # Whether this is fully branch covered depends on the order in which the specs are run.
+      v = handle_date_parse_input(v) if respond_to?(:handle_date_parse_input, true)
+      # :nocov:
+      t = DateTime.parse(v).to_time
+      case application_timezone
+      when nil, :local
+        t = t.localtime
+      end
+      t
+    else
+      super
+    end
+  rescue => e
+    raise convert_exception_class(e, Sequel::InvalidValue)
+  end
+end
+
+Sequel.extend(Sequel::DateTimeParseToTime)