sequel 5.58.0 → 5.78.0

data/lib/sequel/dataset/sql.rb

@@ -82,7 +82,7 @@ module Sequel
       when DateTime
         literal_datetime_append(sql, v)
       when Date
-        sql << literal_date(v)
+        literal_date_append(sql, v)
       when Dataset
         literal_dataset_append(sql, v)
       else
@@ -115,6 +115,33 @@ module Sequel
       sql
     end
 
+    # Literalize a date or time value, as a SQL string value with no
+    # typecasting. If +raw+ is true, remove the surrounding single
+    # quotes.  This is designed for usage by bound argument code that
+    # can work even if the auto_cast_date_and_time extension is
+    # used (either manually or implicitly in the related adapter).
+    def literal_date_or_time(dt, raw=false)
+      value = case dt
+      when SQLTime
+        literal_sqltime(dt)
+      when Time
+        literal_time(dt)
+      when DateTime
+        literal_datetime(dt)
+      when Date
+        literal_date(dt)
+      else
+        raise TypeError, "unsupported type: #{dt.inspect}"
+      end
+
+      if raw
+        value.sub!(/\A'/, '')
+        value.sub!(/'\z/, '')
+      end
+
+      value
+    end
+
     # Returns an array of insert statements for inserting multiple records.
     # This method is used by +multi_insert+ to format insert statements and
     # expects a keys array and and an array of value arrays.
@@ -977,7 +1004,12 @@ module Sequel
     # order if not. Also removes the row_proc, which isn't needed
     # for aggregate calculations.
     def aggregate_dataset
-      (options_overlap(COUNT_FROM_SELF_OPTS) ? from_self : unordered).naked
+      (aggreate_dataset_use_from_self? ? from_self : unordered).naked
+    end
+
+    # Whether to use from_self for an aggregate dataset.
+    def aggreate_dataset_use_from_self?
+      options_overlap(COUNT_FROM_SELF_OPTS)
     end
 
     # Append aliasing expression to SQL string.
@@ -1099,9 +1131,14 @@ module Sequel
       :"t#{number}"
     end
     
-    # The strftime format to use when literalizing the time.
+    # The strftime format to use when literalizing time (Sequel::SQLTime) values.
+    def default_time_format
+      "'%H:%M:%S.%6N'"
+    end
+
+    # The strftime format to use when literalizing timestamp (Time/DateTime) values.
     def default_timestamp_format
-      requires_sql_standard_datetimes? ? "TIMESTAMP '%Y-%m-%d %H:%M:%S%N%z'" : "'%Y-%m-%d %H:%M:%S%N%z'"
+      "'%Y-%m-%d %H:%M:%S.%6N'"
     end
 
     def delete_delete_sql(sql)
@@ -1164,43 +1201,23 @@ module Sequel
       {1 => ((op == :IN) ? 0 : 1)}
     end
     
-    # Format the timestamp based on the default_timestamp_format, with a couple
-    # of modifiers.  First, allow %N to be used for fractions seconds (if the
-    # database supports them), and override %z to always use a numeric offset
-    # of hours and minutes.
+    # Format the timestamp based on the default_timestamp_format.
     def format_timestamp(v)
-      v2 = db.from_application_timestamp(v)
-      fmt = default_timestamp_format.gsub(/%[Nz]/) do |m|
-        if m == '%N'
-          # Ruby 1.9 supports %N in timestamp formats, but Sequel has supported %N
-          # for longer in a different way, where the . is already appended and only 6
-          # decimal places are used by default.
-          format_timestamp_usec(v.is_a?(DateTime) ? v.sec_fraction*(1000000) : v.usec) if supports_timestamp_usecs?
-        else
-          if supports_timestamp_timezones?
-            # Would like to just use %z format, but it doesn't appear to work on Windows
-            # Instead, the offset fragment is constructed manually
-            minutes = (v2.is_a?(DateTime) ? v2.offset * 1440 : v2.utc_offset/60).to_i
-            format_timestamp_offset(*minutes.divmod(60))
-          end
-        end
-      end
-      v2.strftime(fmt)
+      db.from_application_timestamp(v).strftime(default_timestamp_format)
     end
     
-    # Return the SQL timestamp fragment to use for the timezone offset.
-    def format_timestamp_offset(hour, minute)
-      sprintf("%+03i%02i", hour, minute)
-    end
+    # :nocov:
 
     # Return the SQL timestamp fragment to use for the fractional time part.
     # Should start with the decimal point.  Uses 6 decimal places by default.
     def format_timestamp_usec(usec, ts=timestamp_precision)
+      # SEQUEL6: Remove
       unless ts == 6
         usec = usec/(10 ** (6 - ts))
       end
       sprintf(".%0#{ts}d", usec)
     end
+    # :nocov:
 
     # Append literalization of identifier to SQL string, considering regular strings
     # as SQL identifiers instead of SQL strings.
@@ -1342,11 +1359,12 @@ module Sequel
 
     # SQL fragment for Date, using the ISO8601 format.
     def literal_date(v)
-      if requires_sql_standard_datetimes?
-        v.strftime("DATE '%Y-%m-%d'")
-      else
-        v.strftime("'%Y-%m-%d'")
-      end
+      v.strftime("'%Y-%m-%d'")
+    end
+
+    # Append literalization of date to SQL string.
+    def literal_date_append(sql, v)
+      sql << literal_date(v)
     end
 
     # SQL fragment for DateTime
@@ -1409,7 +1427,7 @@ module Sequel
 
     # SQL fragment for Sequel::SQLTime, containing just the time part
     def literal_sqltime(v)
-      v.strftime("'%H:%M:%S#{format_timestamp_usec(v.usec, sqltime_precision) if supports_timestamp_usecs?}'")
+      v.strftime(default_time_format)
     end
 
     # Append literalization of Sequel::SQLTime to SQL string.
@@ -1725,7 +1743,7 @@ module Sequel
     # Append literalization of the subselect to SQL string.
     def subselect_sql_append(sql, ds)
       sds = subselect_sql_dataset(sql, ds)
-      sds.sql
+      subselect_sql_append_sql(sql, sds)
       unless sds.send(:cache_sql?)
         # If subquery dataset does not allow caching SQL,
         # then this dataset should not allow caching SQL.
@@ -1737,6 +1755,10 @@ module Sequel
       ds.clone(:append_sql=>sql)
     end
 
+    def subselect_sql_append_sql(sql, ds)
+      ds.sql
+    end
+
     # The number of decimal digits of precision to use in timestamps.
     def timestamp_precision
       supports_timestamp_usecs? ? 6 : 0

data/lib/sequel/dataset.rb

@@ -53,4 +53,8 @@ module Sequel
   require_relative "dataset/sql"
   require_relative "dataset/placeholder_literalizer"
   require_relative "dataset/dataset_module"
+
+  # :nocov:
+  require_relative "dataset/deprecated_singleton_class_methods" if Dataset::TRUE_FREEZE
+  # :nocov:
 end

data/lib/sequel/exceptions.rb

@@ -18,6 +18,11 @@ module Sequel
       end
     end
   end  
+
+  (
+  # Error raised when there is a failed attempt to acquire an advisory lock.
+  AdvisoryLockError = Class.new(Error)
+  ).name
     
   (
   # Error raised when the adapter requested doesn't exist or can't be loaded.

data/lib/sequel/extensions/_model_pg_row.rb

@@ -23,18 +23,6 @@ module Sequel
             super
           end
         end
-
-        private
-
-        # Handle Sequel::Model instances in bound variable arrays.
-        def bound_variable_array(arg)
-          case arg
-          when Sequel::Model
-            "\"(#{arg.values.values_at(*arg.columns).map{|v| bound_variable_array(v)}.join(',').gsub(/("|\\)/, '\\\\\1')})\""
-          else
-            super
-          end
-        end
       end
     end
   end

data/lib/sequel/extensions/_pretty_table.rb

@@ -39,7 +39,7 @@ module Sequel
 
     # Hash of the maximum size of the value for each column 
     def self.column_sizes(records, columns) # :nodoc:
-      sizes = Hash.new {0}
+      sizes = Hash.new(0)
       columns.each do |c|
         sizes[c] = c.to_s.size
       end

data/lib/sequel/extensions/any_not_empty.rb

@@ -32,8 +32,8 @@
 module Sequel
   module AnyNotEmpty
     # If a block is not given, return whether the dataset is not empty.
-    def any?
-      if defined?(yield)
+    def any?(*a)
+      if !a.empty? || defined?(yield)
         super
       else
         !empty?

data/lib/sequel/extensions/async_thread_pool.rb

@@ -5,9 +5,9 @@
 # code
 #
 #   DB.extension :async_thread_pool
-#   foos = DB[:foos].async.where{:name=>'A'..'M'}.all
+#   foos = DB[:foos].async.where(name: 'A'..'M').all
 #   bar_names = DB[:bar].async.select_order_map(:name)
-#   baz_1 = DB[:bazes].async.first(:id=>1)
+#   baz_1 = DB[:bazes].async.first(id: 1)
 #
 # All 3 queries will be run in separate threads.  +foos+, +bar_names+
 # and +baz_1+ will be proxy objects.  Calling a method on the proxy
@@ -15,9 +15,9 @@
 # of calling that method on the result of the query method. For example,
 # if you run:
 #
-#   foos = DB[:foos].async.where{:name=>'A'..'M'}.all
+#   foos = DB[:foos].async.where(name: 'A'..'M').all
 #   bar_names = DB[:bars].async.select_order_map(:name)
-#   baz_1 = DB[:bazes].async.first(:id=>1)
+#   baz_1 = DB[:bazes].async.first(id: 1)
 #   sleep(1)
 #   foos.size
 #   bar_names.first
@@ -26,9 +26,9 @@
 # These three queries will generally be run concurrently in separate
 # threads.  If you instead run:
 #   
-#   DB[:foos].async.where{:name=>'A'..'M'}.all.size
+#   DB[:foos].async.where(name: 'A'..'M').all.size
 #   DB[:bars].async.select_order_map(:name).first
-#   DB[:bazes].async.first(:id=>1).name
+#   DB[:bazes].async.first(id: 1).name
 #
 # Then will run each query sequentially, since you need the result of
 # one query before running the next query.  The queries will still be
@@ -37,11 +37,11 @@
 # What is run in the separate thread is the entire method call that
 # returns results.  So with the original example:
 #
-#   foos = DB[:foos].async.where{:name=>'A'..'M'}.all
+#   foos = DB[:foos].async.where(name: 'A'..'M').all
 #   bar_names = DB[:bars].async.select_order_map(:name)
-#   baz_1 = DB[:bazes].async.first(:id=>1)
+#   baz_1 = DB[:bazes].async.first(id: 1)
 #
-# The +all+, <tt>select_order_map(:name)</tt>, and <tt>first(:id=>1)</tt>
+# The +all+, <tt>select_order_map(:name)</tt>, and <tt>first(id: 1)</tt>
 # calls are run in separate threads.  If a block is passed to a method
 # such as +all+ or +each+, the block is also run in that thread.  If you
 # have code such as:
@@ -156,10 +156,10 @@
 # so that the query will run in the current thread instead of waiting
 # for an async thread to become available.  With the following code:
 #
-#   foos = DB[:foos].async.where{:name=>'A'..'M'}.all
+#   foos = DB[:foos].async.where(name: 'A'..'M').all
 #   bar_names = DB[:bar].async.select_order_map(:name)
 #   if foos.length > 4
-#     baz_1 = DB[:bazes].async.first(:id=>1)
+#     baz_1 = DB[:bazes].async.first(id: 1)
 #   end
 # 
 # Whether you need the +baz_1+ variable depends on the value of foos.
@@ -176,6 +176,13 @@
 # +:preempt_async_thread+ Database option before loading the
 # async_thread_pool extension.
 #
+# Note that the async_thread_pool extension creates the thread pool
+# when it is loaded into the Database.  If you fork after loading
+# the extension, the extension will not work, as fork does not
+# copy the thread pools.  If you are using a forking webserver
+# (or any other system that forks worker processes), load this
+# extension in each child process, do not load it before forking.
+#
 # Related module: Sequel::Database::AsyncThreadPool::DatasetMethods
 
 
@@ -338,8 +345,9 @@ module Sequel
     module DatabaseMethods
       def self.extended(db)
         db.instance_exec do
-          unless pool.pool_type == :threaded || pool.pool_type == :sharded_threaded
-            raise Error, "can only load async_thread_pool extension if using threaded or sharded_threaded connection pool"
+          case pool.pool_type
+          when :single, :sharded_single
+            raise Error, "cannot load async_thread_pool extension if using single or sharded_single connection pool"
           end
 
           num_async_threads = opts[:num_async_threads] ? typecast_value_integer(opts[:num_async_threads]) : (Integer(opts[:max_connections] || 4))

data/lib/sequel/extensions/auto_cast_date_and_time.rb

@@ -0,0 +1,94 @@
+# frozen-string-literal: true
+#
+# The auto_cast_date_and_time extension uses SQL standard type casting
+# when literalizing date, time, and timestamp values:
+#
+#   DB.literal(Time.now)
+#   # => "TIMESTAMP '...'"
+#
+#   DB.literal(Date.today)
+#   # => "DATE '...'"
+#
+#   DB.literal(Sequel::SQLTime.create(10, 20, 30))
+#   # => "TIME '10:20:30.000000'"
+#
+# The default behavior of Sequel on adapters that do not require the
+# SQL standard behavior is to format the date or time value without:
+# casting
+#
+#   DB.literal(Sequel::SQLTime.create(10, 20, 30))
+#   # => "'10:20:30.000000'"
+#
+# However, then the database cannot determine the type of the string,
+# and must perform some implicit casting.  If implicit casting cannot
+# be used, it will probably treat the value as a string:
+#
+#  DB.get(Time.now).class
+#  # Without auto_cast_date_and_time: String
+#  #    With auto_cast_date_and_time: Time
+#
+# Note that not all databases support this extension. PostgreSQL and
+# MySQL support it, but SQLite and Microsoft SQL Server do not.
+#
+# You can load this extension into specific datasets:
+#
+#   ds = DB[:table]
+#   ds = ds.extension(:auto_cast_date_and_time)
+#
+# Or you can load it into all of a database's datasets, which
+# is probably the desired behavior if you are using this extension:
+#
+#   DB.extension(:auto_cast_date_and_time)
+# 
+# Related module: Sequel::AutoCastDateAndTime
+
+#
+module Sequel
+  module AutoCastDateAndTime
+    # :nocov:
+
+    # Mark the datasets as requiring sql standard date times.  This is only needed
+    # for backwards compatibility.  
+    def requires_sql_standard_datetimes?
+      # SEQUEL6: Remove
+      true
+    end
+    # :nocov:
+
+    private
+
+    # Explicitly cast SQLTime objects to TIME.
+    def literal_sqltime_append(sql, v)
+      sql << "TIME "
+      super
+    end
+
+    # Explicitly cast Time objects to TIMESTAMP.
+    def literal_time_append(sql, v)
+      sql << literal_datetime_timestamp_cast
+      super
+    end
+
+    # Explicitly cast DateTime objects to TIMESTAMP.
+    def literal_datetime_append(sql, v)
+      sql << literal_datetime_timestamp_cast
+      super
+    end
+
+    # Explicitly cast Date objects to DATE.
+    def literal_date_append(sql, v)
+      sql << "DATE "
+      super
+    end
+
+    # The default cast string to use for Time/DateTime objects.
+    # Respects existing method if already defined.
+    def literal_datetime_timestamp_cast
+      return super if defined?(super)
+      'TIMESTAMP '
+    end
+  end
+
+  Dataset.register_extension(:auto_cast_date_and_time, AutoCastDateAndTime)
+end
+

data/lib/sequel/extensions/auto_literal_strings.rb

@@ -22,7 +22,7 @@
 #
 # Named placeholders can also be used with a hash:
 #
-#   ds.where("name > :a", :a=>"A")
+#   ds.where("name > :a", a: "A")
 #   # SELECT * FROM table WHERE (name > 'A')
 #
 # This extension also allows the use of a plain string passed to Dataset#update:

data/lib/sequel/extensions/connection_expiration.rb

@@ -15,16 +15,16 @@
 #
 #   DB.pool.connection_expiration_timeout = 3600 # 1 hour
 #
-# Note that this extension only affects the default threaded
-# and the sharded threaded connection pool.  The single
-# threaded and sharded single threaded connection pools are
-# not affected.  As the only reason to use the single threaded
+# Note that this extension does not work with the single
+# threaded and sharded single threaded connection pools.
+# As the only reason to use the single threaded
 # pools is for speed, and this extension makes the connection
 # pool slower, there's not much point in modifying this
 # extension to work with the single threaded pools.  The
-# threaded pools work fine even in single threaded code, so if
-# you are currently using a single threaded pool and want to
-# use this extension, switch to using a threaded pool.
+# non-single threaded pools work fine even in single threaded
+# code, so if you are currently using a single threaded pool
+# and want to use this extension, switch to using another
+# pool.
 #
 # Related module: Sequel::ConnectionExpiration
 
@@ -45,6 +45,11 @@ module Sequel
 
     # Initialize the data structures used by this extension.
     def self.extended(pool)
+      case pool.pool_type
+      when :single, :sharded_single
+        raise Error, "cannot load connection_expiration extension if using single or sharded_single connection pool"
+      end
+
       pool.instance_exec do
         sync do
           @connection_expiration_timestamps ||= {}
@@ -79,8 +84,9 @@ module Sequel
            (cet = sync{@connection_expiration_timestamps[conn]}) &&
            Sequel.elapsed_seconds_since(cet[0]) > cet[1]
 
-          if pool_type == :sharded_threaded
-            sync{allocated(a.last).delete(Sequel.current)}
+          case pool_type
+          when :sharded_threaded, :sharded_timed_queue
+            sync{@allocated[a.last].delete(Sequel.current)}
           else
             sync{@allocated.delete(Sequel.current)}
           end

data/lib/sequel/extensions/connection_validator.rb

@@ -28,22 +28,22 @@
 # connections on every checkout without setting up coarse
 # connection checkouts will hurt performance, in some cases
 # significantly.  Note that setting up coarse connection
-# checkouts reduces the concurrency level acheivable.  For
+# checkouts reduces the concurrency level achievable.  For
 # example, in a web application, using Database#synchronize
 # in a rack middleware will limit the number of concurrent
 # web requests to the number to connections in the database
 # connection pool.
 #
-# Note that this extension only affects the default threaded
-# and the sharded threaded connection pool.  The single
-# threaded and sharded single threaded connection pools are
-# not affected.  As the only reason to use the single threaded
+# Note that this extension does not work with the single
+# threaded and sharded single threaded connection pools.
+# As the only reason to use the single threaded
 # pools is for speed, and this extension makes the connection
 # pool slower, there's not much point in modifying this
 # extension to work with the single threaded pools.  The
-# threaded pools work fine even in single threaded code, so if
-# you are currently using a single threaded pool and want to
-# use this extension, switch to using a threaded pool.
+# non-single threaded pools work fine even in single threaded
+# code, so if you are currently using a single threaded pool
+# and want to use this extension, switch to using another
+# pool.
 #
 # Related module: Sequel::ConnectionValidator
 
@@ -61,6 +61,11 @@ module Sequel
 
     # Initialize the data structures used by this extension.
     def self.extended(pool)
+      case pool.pool_type
+      when :single, :sharded_single
+        raise Error, "cannot load connection_validator extension if using single or sharded_single connection pool"
+      end
+
       pool.instance_exec do
         sync do
           @connection_timestamps ||= {}
@@ -103,8 +108,9 @@ module Sequel
            Sequel.elapsed_seconds_since(timer) > @connection_validation_timeout &&
            !db.valid_connection?(conn)
 
-          if pool_type == :sharded_threaded
-            sync{allocated(a.last).delete(Sequel.current)}
+          case pool_type
+          when :sharded_threaded, :sharded_timed_queue
+            sync{@allocated[a.last].delete(Sequel.current)}
           else
             sync{@allocated.delete(Sequel.current)}
           end
@@ -120,4 +126,3 @@ module Sequel
 
   Database.register_extension(:connection_validator){|db| db.pool.extend(ConnectionValidator)}
 end
-

data/lib/sequel/extensions/constraint_validations.rb

@@ -126,7 +126,7 @@
 #   be emulated by dropping the table and recreating it with the constraints.
 #   If you want to use this plugin on SQLite with an alter_table block,
 #   you should drop all constraint validation metadata using
-#   <tt>drop_constraint_validations_for(:table=>'table')</tt>, and then
+#   <tt>drop_constraint_validations_for(table: 'table')</tt>, and then
 #   readd all constraints you want to use inside the alter table block,
 #   making no other changes inside the alter_table block.
 #

data/lib/sequel/extensions/date_arithmetic.rb

@@ -25,13 +25,17 @@
 # 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)
+#   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
 
 #
@@ -54,7 +58,16 @@ module Sequel
           interval = interval.parts
         end
         parts = {}
-        interval.each{|k,v| parts[k] = -v unless v.nil?}
+        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, parts, opts)
       end
     end
@@ -68,6 +81,7 @@ 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
@@ -87,14 +101,28 @@ module Sequel
 
           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, cast_type))
+
+            if interval
+              return complex_expression_sql_append(sql, :+, [casted, interval])
             else
-              return complex_expression_sql_append(sql, :+, [Sequel.cast(expr, cast_type), Sequel.cast(interval, :interval)])
+              return literal_append(sql, casted)
             end
           when :sqlite
             args = [expr]

data/lib/sequel/extensions/duplicate_columns_handler.rb

@@ -14,12 +14,12 @@
 #
 #   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.
+# If the Database option :on_duplicate_columns is set, it configures how this
+# extension works. The value should be # or any object that responds to :call.
 #
-#   on_duplicate_columns: :raise
-#   on_duplicate_columns: :warn
-#   on_duplicate_columns: :ignore
+#   on_duplicate_columns: :raise # or 'raise'
+#   on_duplicate_columns: :warn # or 'warn'
+#   on_duplicate_columns: :ignore # or anything unrecognized
 #   on_duplicate_columns: lambda{|columns| arbitrary_condition? ? :raise : :warn}
 #
 # You may also configure duplicate columns handling for a specific dataset:
@@ -30,9 +30,10 @@
 #   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 :raise or 'raise' is specified, a Sequel::DuplicateColumnError is raised.
+# If :warn or 'warn' is specified, you will receive a warning via +warn+.
 # If a callable is specified, it will be called.
+# For other values, duplicate columns are ignored (Sequel's default behavior)
 # If no on_duplicate_columns is specified, the default is :warn.
 #
 # Related module: Sequel::DuplicateColumnsHandler
@@ -64,9 +65,9 @@ module Sequel
       message = "#{caller(*CALLER_ARGS).first}: One or more duplicate columns present in #{cols.inspect}"
 
       case duplicate_columns_handler_type(cols)
-      when :raise
+      when :raise, 'raise'
         raise DuplicateColumnError, message
-      when :warn
+      when :warn, 'warn'
         warn message
       end
     end