sequel 4.26.0 → 5.37.0

data/lib/sequel/extensions/dataset_source_alias.rb

@@ -1,3 +1,5 @@
+# frozen-string-literal: true
+#
 # The dataset_source_alias extension changes Sequel's
 # default behavior of automatically aliasing datasets
 # from using t1, t2, etc. to using an alias based on
@@ -35,6 +37,8 @@
 # is probably the desired behavior if you are using this extension:
 #
 #   DB.extension(:dataset_source_alias)
+#
+# Related module: Sequel::Dataset::DatasetSourceAlias
 
 #
 module Sequel

data/lib/sequel/extensions/date_arithmetic.rb

@@ -1,3 +1,5 @@
+# frozen-string-literal: true
+#
 # The date_arithmetic extension adds the ability to perform database-independent
 # addition/substraction of intervals to/from dates and timestamps.
 #
@@ -8,8 +10,8 @@
 # Then you can use the Sequel.date_add and Sequel.date_sub methods
 # to return Sequel expressions:
 #
-#   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, days: 3)
+#   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
@@ -19,23 +21,34 @@
 #   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)
+#
+# Related module: Sequel::SQL::DateAdd
 
 #
 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)
+      # Options:
+      # :cast :: Cast to the specified type instead of the default if casting
+      def date_sub(expr, interval, opts=OPTS)
         interval = if interval.is_a?(Hash)
           h = {}
           interval.each{|k,v| h[k] = -v unless v.nil?}
@@ -43,7 +56,7 @@ module Sequel
         else
           -interval
         end
-        DateAdd.new(expr, interval)
+        DateAdd.new(expr, interval, opts)
       end
     end
 
@@ -62,22 +75,27 @@ module Sequel
         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 = ""
+            interval = String.new
             each_valid_interval_unit(h, DEF_DURATION_UNITS) do |value, sql_unit|
               interval << "#{value} #{sql_unit} "
             end
             if interval.empty?
-              return literal_append(sql, Sequel.cast(expr, Time))
+              return literal_append(sql, Sequel.cast(expr, cast_type))
             else
-              return complex_expression_sql_append(sql, :+, [Sequel.cast(expr, Time), Sequel.cast(interval, :interval)])
+              return complex_expression_sql_append(sql, :+, [Sequel.cast(expr, cast_type), Sequel.cast(interval, :interval)])
             end
           when :sqlite
             args = [expr]
@@ -85,10 +103,10 @@ 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))
@@ -118,7 +136,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
@@ -128,7 +146,7 @@ module Sequel
           end
 
           if cast
-            expr = Sequel.cast(expr, Time)
+            expr = Sequel.cast(expr, cast_type)
           end
 
           literal_append(sql, expr)
@@ -159,10 +177,14 @@ 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|
@@ -172,12 +194,16 @@ module Sequel
                raise Sequel::InvalidValue, "cannot provide String value as interval part: #{v.inspect}"
              end
           end
-          interval
+          Hash[interval]
         else
           h = Hash.new(0)
           interval.parts.each{|unit, value| h[unit] += value}
           Hash[h]
         end
+
+        @interval.freeze
+        @cast_type = opts[:cast] if opts[:cast]
+        freeze
       end
 
       to_s_method :date_add_sql

data/lib/sequel/extensions/datetime_parse_to_time.rb

@@ -0,0 +1,37 @@
+# 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)
+      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)

data/lib/sequel/extensions/duplicate_columns_handler.rb

@@ -0,0 +1,94 @@
+# frozen-string-literal: true
+#
+# The duplicate_columns_handler extension allows you to customize handling of
+# duplicate column names in your queries on a per-database or per-dataset level.
+#
+# For example, you may want to raise an exception if you join 2 tables together
+# which contains a column that will override another columns.
+#
+# To use the extension, you need to load the extension into the database:
+#
+#   DB.extension :duplicate_columns_handler
+#
+# or into individual datasets:
+#
+#   ds = DB[:items].extension(:duplicate_columns_handler)
+#
+# A database option is introduced: :on_duplicate_columns. It accepts a Symbol
+# or any object that responds to :call.
+#
+#   on_duplicate_columns: :raise
+#   on_duplicate_columns: :warn
+#   on_duplicate_columns: :ignore
+#   on_duplicate_columns: lambda{|columns| arbitrary_condition? ? :raise : :warn}
+#
+# You may also configure duplicate columns handling for a specific dataset:
+#
+#   ds.on_duplicate_columns(:warn)
+#   ds.on_duplicate_columns(:raise)
+#   ds.on_duplicate_columns(:ignore)
+#   ds.on_duplicate_columns{|columns| arbitrary_condition? ? :raise : :warn}
+#   ds.on_duplicate_columns(lambda{|columns| arbitrary_condition? ? :raise : :warn})
+#
+# If :raise is specified, a Sequel::DuplicateColumnError is raised.
+# If :warn is specified, you will receive a warning via +warn+.
+# If a callable is specified, it will be called.
+# If no on_duplicate_columns is specified, the default is :warn.
+#
+# Related module: Sequel::DuplicateColumnsHandler
+
+module Sequel
+  module DuplicateColumnsHandler
+    # :nocov:
+    CALLER_ARGS = (RUBY_VERSION >= '2.0' ? [0,1] : [0]).freeze
+    # :nocov:
+
+    # Customize handling of duplicate columns for this dataset.
+    def on_duplicate_columns(handler = (raise Error, "Must provide either an argument or a block to on_duplicate_columns" unless block_given?; nil), &block)
+      raise Error, "Cannot provide both an argument and a block to on_duplicate_columns" if handler && block
+      clone(:on_duplicate_columns=>handler||block)
+    end
+
+    private
+
+    # Call handle_duplicate_columns if there are duplicate columns.
+    def columns=(cols)
+      if cols && cols.uniq.size != cols.size
+        handle_duplicate_columns(cols)
+      end
+      super
+    end
+
+    # Invoke the appropriate behavior when duplicate columns are present.
+    def handle_duplicate_columns(cols)
+      message = "#{caller(*CALLER_ARGS).first}: One or more duplicate columns present in #{cols.inspect}"
+
+      case duplicate_columns_handler_type(cols)
+      when :raise
+        raise DuplicateColumnError, message
+      when :warn
+        warn message
+      end
+    end
+
+    # Try to find dataset option for on_duplicate_columns. If not present on the dataset,
+    # use the on_duplicate_columns option on the database. If not present on the database,
+    # default to :warn.
+    def duplicate_columns_handler_type(cols)
+      handler = opts.fetch(:on_duplicate_columns){db.opts.fetch(:on_duplicate_columns, :warn)}
+
+      if handler.respond_to?(:call)
+        handler.call(cols)
+      else
+        handler
+      end
+    end
+  end
+
+  # Error which is raised when duplicate columns are present in a dataset which is configured
+  # to :raise on_duplicate_columns.
+  class DuplicateColumnError < Error
+  end
+
+  Dataset.register_extension(:duplicate_columns_handler, Sequel::DuplicateColumnsHandler)
+end

data/lib/sequel/extensions/empty_array_consider_nulls.rb

@@ -1,10 +1,12 @@
+# frozen-string-literal: true
+#
 # This changes Sequel's literalization of IN/NOT IN with an empty
 # array value to consider NULL values if one of the referenced
 # columns is NULL:
 #
-#   DB[:test].where(:name=>[])
+#   DB[:test].where(name: [])
 #   # SELECT * FROM test WHERE (name != name)
-#   DB[:test].exclude(:name=>[])
+#   DB[:test].exclude(name: [])
 #   # SELECT * FROM test WHERE (name = name)
 #
 # The default Sequel behavior is to ignore NULLs, as the above
@@ -19,11 +21,13 @@
 # is probably the desired behavior if you are using this extension:
 #
 #   DB.extension(:empty_array_consider_nulls)
+#
+# Related module: Sequel::EmptyArrayConsiderNulls
 
 #
 module Sequel
   module EmptyArrayConsiderNulls
-    # Use a simple expression that is always true or false, never NULL.
+    # Use an expression that returns NULL if the column value is NULL.
     def empty_array_value(op, cols)
       c = Array(cols)
       SQL::BooleanExpression.from_value_pairs(c.zip(c), :AND, op == :IN)

data/lib/sequel/extensions/error_sql.rb

@@ -1,3 +1,5 @@
+# frozen-string-literal: true
+#
 # The error_sql extension adds a DatabaseError#sql method
 # that you can use to get the sql that caused the error
 # to be raised.
@@ -18,7 +20,7 @@
 #
 # This extension may not work correctly in the following cases:
 #
-# * log_yield is not used when executing the query.
+# * log_connection_yield is not used when executing the query.
 # * The underlying exception is frozen or reused.
 # * The underlying exception doesn't correctly record instance
 #   variables set on it (seems to happen on JRuby when underlying
@@ -27,6 +29,8 @@
 # To load the extension into the database:
 #
 #   DB.extension :error_sql
+#
+# Related module: Sequel::ErrorSQL
 
 #
 module Sequel
@@ -53,12 +57,12 @@ module Sequel
     # If there are no loggers for this database and an exception is raised
     # store the SQL related to the exception with the exception, so it
     # is available for DatabaseError#sql later.
-    def log_yield(sql, args=nil)
+    def log_connection_yield(sql, conn, args=nil)
       if @loggers.empty?
         begin
           yield
         rescue => e
-          sql = "#{sql}; #{args.inspect}" if args
+          sql = "#{connection_info(conn) if conn && log_connection_info}#{sql}#{"; #{args.inspect}" if args}"
           e.instance_variable_set(:@sequel_error_sql, sql)
           raise
         end

data/lib/sequel/extensions/escaped_like.rb

@@ -0,0 +1,100 @@
+# frozen-string-literal: true
+#
+# The escaped_like extension adds +escaped_like+ and +escaped_ilike+
+# methods to Sequel::SQL::StringMethods, which allow them to be easily
+# used with most of Sequel's expression objects.  Example:
+#
+#   DB[:table].where{string_column.escaped_like('?%', user_input)}
+#   # user_input is 'foo':
+#   #  SELECT * FROM table WHERE string_column LIKE 'foo%' ESCAPE '\'
+#   # user_input is '%foo':
+#   #  SELECT * FROM table WHERE string_column LIKE '\%foo%' ESCAPE '\'
+#
+# To load the extension:
+#
+#   Sequel.extension :escaped_like
+#
+# Related modules: Sequel::SQL::StringMethods, Sequel::SQL::EscapedLikeExpression
+
+#
+module Sequel
+  module SQL
+    # Represents an pattern match SQL expression, where the pattern can depend
+    # upon interpolated values in a database-dependent manner.
+    class EscapedLikeExpression < Expression
+      include AliasMethods
+      include BooleanMethods
+      include CastMethods
+      include OrderMethods
+
+      # Initialize the expression. Arguments:
+      # expr :: Right hand site of LIKE/ILIKE operator, what you are matching against the pattern
+      # case_insensitive :: Whether the match is case sensitive
+      # placeholder_pattern :: The pattern to match against, with +?+ for the placeholders
+      # placeholder_values :: The string values for each +?+ in the placeholder pattern.  Should be an
+      #                       array of strings, though it can be a single string if there is only
+      #                       a single placeholder.
+      def initialize(expr, case_sensitive, placeholder_pattern, placeholder_values)
+        @expr = expr
+        @method = case_sensitive ? :like : :ilike
+        @pattern = placeholder_pattern
+        unless placeholder_values.is_a?(Array)
+          placeholder_values = [placeholder_values].freeze
+        end
+        @values = placeholder_values
+        freeze
+      end
+
+      # Interpolate the pattern values into the placeholder pattern to get the final pattern,
+      # now that we have access to the dataset.  Use the expression and final pattern and
+      # add an appropriate LIKE/ILIKE expression to the SQL being built.
+      def to_s_append(ds, sql)
+        i = -1
+        match_len = @values.length - 1
+        like_pattern = String.new
+        pattern = @pattern
+        while true
+          previous, q, pattern = pattern.partition('?')
+          like_pattern << previous
+
+          unless q.empty?
+            if i == match_len
+              raise Error, "Mismatched number of placeholders (#{i+1}) and placeholder arguments (#{@values.length}) for escaped like expression: #{@pattern.inspect}"
+            end
+            like_pattern << ds.escape_like(@values.at(i+=1))
+          end
+
+          if pattern.empty?
+            unless i == match_len
+              raise Error, "Mismatched number of placeholders (#{i+1}) and placeholder arguments (#{@values.length}) for escaped like expression: #{@pattern.inspect}"
+            end
+            break
+          end
+        end
+        ds.literal_append(sql, Sequel.send(@method, @expr, like_pattern))
+      end
+    end
+
+    module StringMethods
+      # Create a +EscapedLikeExpression+ case insensitive pattern match of the receiver
+      # with the patterns, interpolated escaped values for each +?+ placeholder in the
+      # pattern. 
+      #
+      #   Sequel[:a].escaped_ilike('?%', 'A') # "a" ILIKE 'A%' ESCAPE '\'
+      #   Sequel[:a].escaped_ilike('?%', '%A') # "a" ILIKE '\%A%' ESCAPE '\'
+      def escaped_ilike(placeholder_pattern, placeholder_values)
+        EscapedLikeExpression.new(self, false, placeholder_pattern, placeholder_values)
+      end
+
+      # Create a +EscapedLikeExpression+ case sensitive pattern match of the receiver
+      # with the patterns, interpolated escaped values for each +?+ placeholder in the
+      # pattern. 
+      #
+      #   Sequel[:a].escaped_like('?%', 'A') # "a" LIKE 'A%' ESCAPE '\'
+      #   Sequel[:a].escaped_like('?%', '%A') # "a" LIKE '\%A%' ESCAPE '\'
+      def escaped_like(placeholder_pattern, placeholder_values)
+        EscapedLikeExpression.new(self, true, placeholder_pattern, placeholder_values)
+      end
+    end
+  end
+end