sequel 5.68.0 → 5.77.0

data/lib/sequel/connection_pool.rb

@@ -32,6 +32,7 @@ class Sequel::ConnectionPool
     :sharded_threaded => :ShardedThreadedConnectionPool,
     :sharded_single => :ShardedSingleConnectionPool,
     :timed_queue => :TimedQueueConnectionPool,
+    :sharded_timed_queue => :ShardedTimedQueueConnectionPool,
   }
   POOL_CLASS_MAP.to_a.each{|k, v| POOL_CLASS_MAP[k.to_s] = v}
   POOL_CLASS_MAP.freeze
@@ -42,7 +43,8 @@ class Sequel::ConnectionPool
     # Return a pool subclass instance based on the given options.  If a <tt>:pool_class</tt>
     # option is provided is provided, use that pool class, otherwise
     # use a new instance of an appropriate pool subclass based on the
-    # <tt>:single_threaded</tt> and <tt>:servers</tt> options.
+    # +SEQUEL_DEFAULT_CONNECTION_POOL+ environment variable if set, or
+    # the <tt>:single_threaded</tt> and <tt>:servers</tt> options, otherwise.
     def get_pool(db, opts = OPTS)
       connection_pool_class(opts).new(db, opts)
     end
@@ -62,9 +64,16 @@ class Sequel::ConnectionPool
         end
 
         pc
+      elsif pc = ENV['SEQUEL_DEFAULT_CONNECTION_POOL']
+        pc = "sharded_#{pc}" if opts[:servers] && !pc.start_with?('sharded_')
+        connection_pool_class(:pool_class=>pc)
       else
         pc = if opts[:single_threaded]
           opts[:servers] ? :sharded_single : :single
+        # :nocov:
+        elsif RUBY_VERSION >= '3.4' # SEQUEL6 or maybe earlier switch to 3.2
+          opts[:servers] ? :sharded_timed_queue : :timed_queue
+        # :nocov:
         else
           opts[:servers] ? :sharded_threaded : :threaded
         end

data/lib/sequel/database/connecting.rb

@@ -8,7 +8,7 @@ module Sequel
     # ---------------------
 
     # Array of supported database adapters
-    ADAPTERS = %w'ado amalgalite ibmdb jdbc mock mysql mysql2 odbc oracle postgres sqlanywhere sqlite tinytds'.map(&:to_sym)
+    ADAPTERS = %w'ado amalgalite ibmdb jdbc mock mysql mysql2 odbc oracle postgres sqlanywhere sqlite tinytds trilogy'.map(&:to_sym)
 
     # The Database subclass for the given adapter scheme.
     # Raises Sequel::AdapterNotFound if the adapter

data/lib/sequel/database/misc.rb

@@ -263,8 +263,8 @@ module Sequel
     # Proxy the literal call to the dataset.
     #
     #   DB.literal(1)   # 1
-    #   DB.literal(:a)  # a
-    #   DB.literal('a') # 'a'
+    #   DB.literal(:a)  # "a" # or `a`, [a], or a, depending on identifier quoting
+    #   DB.literal("a") # 'a'
     def literal(v)
       schema_utility_dataset.literal(v)
     end

data/lib/sequel/database/schema_methods.rb

@@ -191,6 +191,12 @@ module Sequel
     #            The +any+ type is treated like a SQLite column in a non-strict table,
     #            allowing any type of data to be stored. This option is supported on
     #            SQLite 3.37.0+.
+    # :without_rowid :: Create a WITHOUT ROWID table. Every row in SQLite has a special
+    #                   'rowid' column, that uniquely identifies that row within the table.
+    #                   If this option is used, the 'rowid' column is omitted, which can
+    #                   sometimes provide some space and speed advantages. Note that you
+    #                   must then provide an explicit primary key when you create the table.
+    #                   This option is supported on SQLite 3.8.2+.
     #
     # See <tt>Schema::CreateTableGenerator</tt> and the {"Schema Modification" guide}[rdoc-ref:doc/schema_modification.rdoc].
     def create_table(name, options=OPTS, &block)
@@ -712,8 +718,9 @@ module Sequel
       e = options[:ignore_index_errors] || options[:if_not_exists]
       generator.indexes.each do |index|
         begin
-          pr = proc{index_sql_list(name, [index]).each{|sql| execute_ddl(sql)}}
-          supports_transactional_ddl? ? transaction(:savepoint=>:only, &pr) : pr.call
+          transaction(:savepoint=>:only, :skip_transaction=>supports_transactional_ddl? == false) do
+            index_sql_list(name, [index]).each{|sql| execute_ddl(sql)}
+          end
         rescue Error
           raise unless e
         end

data/lib/sequel/database/transactions.rb

@@ -166,6 +166,8 @@ module Sequel
     #               uses :auto_savepoint, you can set this to false to not use a savepoint.
     #               If the value given for this option is :only, it will only create a
     #               savepoint if it is inside a transaction.
+    # :skip_transaction :: If set, do not actually open a transaction or savepoint,
+    #                      just checkout a connection and yield it.
     #
     # PostgreSQL specific options:
     #
@@ -193,6 +195,10 @@ module Sequel
         end
       else
         synchronize(opts[:server]) do |conn|
+          if opts[:skip_transaction]
+            return yield(conn)
+          end
+
           if opts[:savepoint] == :only
             if supports_savepoints?
               if _trans(conn)

data/lib/sequel/dataset/actions.rb

@@ -356,9 +356,11 @@ module Sequel
     #            This does not have an effect if +values+ is a Dataset.
     # :server :: Set the server/shard to use for the transaction and insert
     #            queries.
+    # :skip_transaction :: Do not use a transaction even when using multiple
+    #                      INSERT queries.
     # :slice :: Same as :commit_every, :commit_every takes precedence.
     def import(columns, values, opts=OPTS)
-      return @db.transaction{insert(columns, values)} if values.is_a?(Dataset)
+      return insert(columns, values) if values.is_a?(Dataset)
 
       return if values.empty?
       raise(Error, 'Using Sequel::Dataset#import with an empty column array is not allowed') if columns.empty?
@@ -588,6 +590,8 @@ module Sequel
     #                   if your ORDER BY expressions are not simple columns, if they contain
     #                   qualified identifiers that would be ambiguous unqualified, if they contain
     #                   any identifiers that are aliased in SELECT, and potentially other cases.
+    # :skip_transaction :: Do not use a transaction. This can be useful if you want to prevent
+    #                      a lock on the database table, at the expense of consistency.
     #
     # Examples:
     #
@@ -1111,11 +1115,9 @@ module Sequel
     # are provided. When only a single value or statement is provided, then yield
     # without using a transaction.
     def _import_transaction(values, trans_opts, &block)
-      if values.length > 1
-        @db.transaction(trans_opts, &block)
-      else
-        yield
-      end
+      # OK to mutate trans_opts as it is generated by _import
+      trans_opts[:skip_transaction] = true if values.length <= 1
+      @db.transaction(trans_opts, &block)
     end
   
     # Internals of +select_hash+ and +select_hash_groups+

data/lib/sequel/dataset/features.rb

@@ -25,11 +25,16 @@ module Sequel
       false
     end
 
+    # :nocov:
+
     # Whether the dataset requires SQL standard datetimes. False by default,
-    # as most allow strings with ISO 8601 format.
+    # as most allow strings with ISO 8601 format. Only for backwards compatibility,
+    # no longer used internally, do not use in new code.
     def requires_sql_standard_datetimes?
+      # SEQUEL6: Remove
       false
     end
+    # :nocov:
 
     # Whether type specifiers are required for prepared statement/bound
     # variable argument placeholders (i.e. :bv__integer), false by default.
@@ -183,10 +188,14 @@ module Sequel
       true
     end
 
+    # :nocov:
+
     # Whether the dataset supports timezones in literal timestamps, false by default.
     def supports_timestamp_timezones?
+      # SEQUEL6: Remove
       false
     end
+    # :nocov:
     
     # Whether the dataset supports fractional seconds in literal timestamps, true by default.
     def supports_timestamp_usecs?

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.
@@ -1104,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)
@@ -1169,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.
@@ -1347,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
@@ -1414,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.

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

@@ -338,8 +338,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/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

@@ -34,16 +34,16 @@
 # 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/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

data/lib/sequel/extensions/index_caching.rb

@@ -56,7 +56,11 @@ module Sequel
     
     # Dump the index cache to the filename given in Marshal format.
     def dump_index_cache(file)
-      File.open(file, 'wb'){|f| f.write(Marshal.dump(@indexes))}
+      indexes = {}
+      @indexes.sort.each do |k, v|
+        indexes[k] = v
+      end
+      File.open(file, 'wb'){|f| f.write(Marshal.dump(indexes))}
       nil
     end