sequel 5.75.0 → 5.77.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3047129164c9cdffee31414419904329e410db71e7e4243c0549614498a2b0d4
-  data.tar.gz: 9cc84ed8e9dba53aac7175be04699089932566e4015aed7a465c43552808c8b4
+  metadata.gz: 9951772dd3785c8ce91090bd31034a1e57ac5dcbc17af774b980a115cea15347
+  data.tar.gz: 3cfcaefaf6aa4758ef2cfaf78cbe6ccdc688e8b3836718bd63c42c5bdb220026
 SHA512:
-  metadata.gz: 15ed5c13e4793191546cd452aa5865e65fd7b3bb0458ffdb674d526398b7c9446e2da0f43a339daa3f1dc256eb551f0b773ac9ffc192b4d19f389d0c7e296d98
-  data.tar.gz: 1f25851b50857fbbf8378216794f26d0d8e9baa247f008feac466a218ae6b0777249252b6d05756e075096c5312b9d3b1334b7c4bc1884251e7b892cc17ae7c6
+  metadata.gz: '0885577c11fd7285a5278d0a1b52ae411e557cec7bce2f3a49f8128a0be63928ebfa55b2b1a86c8b28ee1c3782c1dc5ebf5d4ecf00f0194ad33da89cb6ffc12a'
+  data.tar.gz: ccc7b8b6c68049ee1fed2211a3d193157ee36fde9c340324eba2a8cebd8925bc97b4dc1777b61f8a2fb94d83439c41f33afb832c080f4d54bab16d09924a4fe2

data/CHANGELOG

@@ -1,3 +1,51 @@
+=== 5.77.0 (2024-02-01)
+
+* Support create_table :without_rowid option on SQLite (loranger32) (#2126)
+
+* Warn by default if trying to eager_graph/association_join an association that uses a block, when the block would be ignored (jeremyevans)
+
+* Speed up validates_unique in validation_helpers plugin by using empty? instead of count == 0 (numbata) (#2122)
+
+* Speed up regexp matches in sqlite adapter on Ruby 2.4+ (jeremyevans)
+
+* Add sqlite adapter :regexp_function_cache option for specifying the cache object to use (paddor, jeremyevans) (#2116)
+
+* Respect list plugin :top option when inserting the first row into the model's table (johanmagnusson) (#2115)
+
+* Switch default connection pool to timed_queue on Ruby 3.4+ (jeremyevans)
+
+* Support on_duplicate_columns={raise,warn} parameter in connection URL when using duplicate_columns_handler extension (jeremyevans)
+
+* Add transaction_connection_validator extension for retrying transactions on new connection if ther is a disconnect error when starting transaction (jeremyevans)
+
+=== 5.76.0 (2024-01-01)
+
+* Improve performance and flexibility of regexp matching in sqlite adapter (paddor) (#2108)
+
+* Support SQL::Identifier for Database#tables :schema option values on PostgreSQL (jeremyevans)
+
+* Support generating rcte queries using UNION or UNION ALL in the rcte plugin (jonathanfrias) (#2107)
+
+* Make Database#table_exists? on PostgreSQL handle lock or statement timeout errors as evidence the table exists (jeremyevans) (#2106)
+
+* Work around DateTime.jd fractional second bug on JRuby in named_timezones extension (jeremyevans)
+
+* Support fractional times and timestamps on SQLAnywhere (jeremyevans)
+
+* Make round_timestamps extension use Dataset#sqltime_precision for rounding Sequel::SQLTime values (jeremyevans)
+
+* Remove special handling of %N modifier in Dataset#default_timestamp_format (jeremyevans)
+
+* Add Dataset#default_time_format private method, for adapters to override for time (not timestamp) formatting (jeremyevans)
+
+* Remove Dataset#format_timestamp_offset private method (jeremyevans)
+
+* Remove special handling of %z modifier in Dataset#default_timestamp_format (jeremyevans)
+
+* Add Dataset#literal_date_or_time, for simpler use by bound argument code (jeremyevans)
+
+* Add auto_cast_date_and_time extension, for casting date and time values using SQL standard functions (jeremyevans)
+
 === 5.75.0 (2023-12-01)
 
 * Make any_not_empty? extension support passing pattern argument to any? (jeremyevans) (#2100)

data/doc/opening_databases.rdoc

@@ -388,8 +388,10 @@ The following additional options are supported:
 :readonly :: open database in read-only mode
 :timeout :: the busy timeout to use in milliseconds (default: 5000).
 :setup_regexp_function :: Whether to setup a REGEXP function in the underlying SQLite3::Database object. Doing so
-                          allows you to use regexp support in dataset expressions.  Note that this creates a new
-                          Regexp object per call to the function, so it is not an efficient implementation.
+                          allows you to use regexp support in dataset expressions.  If +:cached+ or <tt>"cached"</tt>+, caches each
+                          unique regex (more efficient but risk of memory leak). If a Proc is provided, it will be called with
+                          a string for the regexp and a string for the value to compare, and should return whether the regexp
+                          string matches the string value to compare. The default Proc used does <tt>Regexp.new(regexp_str).match(str)</tt>.
 
 Note that SQLite memory databases are restricted to a single connection by
 default.  This is because SQLite does not allow multiple connections to

data/doc/release_notes/5.76.0.txt

@@ -0,0 +1,86 @@
+= New Features
+
+* An auto_cast_date_and_time extension has been added, which will
+  automatically cast date and time values using SQL standard functions.
+  This makes sure the database will treat the value as a date, time,
+  or timestamp, instead of treating it as a string or unknown type:
+
+    DB.get(Date.today).class
+    # SELECT '2024-01-01' AS v LIMIT 1
+    String
+
+    DB.extension(:auto_cast_date_and_time)
+    DB.get(Date.today).class
+    # SELECT DATE '2024-01-01' AS v LIMIT 1
+    Date
+
+  This was already Sequel's default behavior on adapters that required
+  it.  This extension is usable on PostgreSQL and MySQL.  It is not
+  usable on SQLite (no date/time types) or Microsoft SQL Server (no
+  support for the SQL standard conversion syntax).
+
+  This extension can break code that currently works. If using it on
+  PostgreSQL, it will cast the values to TIMESTAMP, not TIMESTAMP
+  WITH TIME ZONE, which can break code that depended on an implicit
+  conversion to TIMESTAMP WITH TIME ZONE.  The pg_timestamptz
+  extension integrates with the the auto_cast_date_and_time extension
+  and will implicitly cast Time/DateTime to TIMESTAMP WITH TIME ZONE.
+
+* The sqlite adapter now supports a :cached value for the
+  :setup_regexp_function Database option, which will cache regexp
+  values instead of creating a new regexp per value to compare.  This
+  is much faster when using a regexp comparison on a large dataset,
+  but can result in a memory leak if using dynamic regexps. You can
+  also provide a Proc value for the :setup_regexp_function option,
+  which will be passed both the regexp source string and the database
+  string to compare, and should return whether the database string
+  matches the regexp string.
+
+* The rcte_tree plugin now supports a :union_all option, which can
+  be set to false to use UNION instead of UNION ALL in the recursive
+  common table expression.
+
+= Other Improvements
+
+* Time/DateTime/SQLTime literalization speed has more than doubled
+  compared to the previous version.  The internal code is also much
+  simpler, as the speedup resulted from removing multiple abstraction
+  layers that mostly existed for Ruby 1.8 support.
+
+* Database#table_exists? on PostgreSQL now handles lock or statement
+  timeout errors as evidence the table exists.
+
+* The round_timestamps extension now correctly rounds SQLTime values
+  on Microsoft SQL Server (the only database Sequel supports where
+  time precision is different than timestamp precision).
+
+* Fractional times and timestamps are now supported on SQLAnywhere,
+  except for time values when using the jdbc adapter due to a
+  limitation in the JDBC sqlanywhere driver.
+
+* Database#tables and #views on PostgreSQL now supports
+  SQL::Identifier values for the :schema option.
+
+* The named_timezones extension now works around a bug in DateTime.jd
+  on JRuby.
+
+= Backwards Compatibility
+
+* Time/DateTime/SQLTime literalization internals have changed.
+  If you are using an external adapter and the external adapter
+  overrides or calls any of the following methods:
+
+  * requires_sql_standard_datetimes?
+  * supports_timestamp_usecs?
+  * supports_timestamp_timezones?
+  * timestamp_precision
+  * sqltime_precision
+
+  then the adapter may need to be updated to support Sequel 5.76.0.
+  Additionally, if the adapter uses %N or %z in
+  default_timestamp_format, it may need to be updated. Adapters
+  should now just override default_timestamp_format and/or
+  default_time_format methods as appropriate for the database.
+
+* The Dataset#format_timestamp_offset private method has been
+  removed.

data/doc/release_notes/5.77.0.txt

@@ -0,0 +1,63 @@
+= New Features
+
+* A transaction_connection_validator extension has been added.  This
+  extension allows for transparently switching to a new connection if
+  a disconnect error is raised while trying to start a transaction, as
+  long as a connection was not already checked out from the pool
+  when the transaction method was called.  Transparent reconnection
+  is safe in this case, since no user code is retried.
+
+  This extension can have lower overhead than the
+  connection_validator extension if that is configured to check for
+  validity more often than the default of one hour.  However, it
+  only handles cases where transactions are used.  It can detect
+  disconnects that would not be detected by default with the
+  connection_validator extension, since that extension defaults to
+  only checking validity if the connection has not been used in the
+  last hour.
+
+* Sequel now supports a create_table :without_rowid option on SQLite,
+  to create a table WITHOUT ROWID, for better performance in some
+  cases. Users are encouraged to read the SQLite documentation on
+  WITHOUT ROWID before using this option.
+
+* The sqlite adapter now supports a :regexp_function_cache option, if
+  the :setup_regexp_function option is set to :cached.  The
+  :regexp_function_cache option should be a Proc (returning a cache
+  object to use), or a class.  It's possible to use
+  ObjectSpace::WeakKeyMap as the value of the option on Ruby 3.3+
+  to avoid the memory leaks that are possible when using
+  :setup_regexp_function option :cached value with dynamic regexps.
+
+* The duplicate_columns_handler extension now supports specifying
+  the on_duplicate_columns option as a connection string parameter.
+
+= Other Improvements
+
+* The list plugin now honors the :top option for the position when
+  adding the first item to the list, instead of always using 1.
+
+* Regexp matches on SQLite are now faster on Ruby 2.4+, using
+  Regexp#match?.
+
+* The uniqueness validation in the validation_helpers plugin now
+  uses empty? instead of count == 0, for better performance.
+
+* On Ruby 3.4+, Sequel uses the timed_queue connection pool instead
+  of the threaded connection pool by default.  This should make it
+  so no existing applications are affected by the default switch.
+  This should hopefully allow ample testing of the timed_queue
+  connection pool.  At some point in the future, if no problems
+  are repoted, Sequel will likely switch to using the timed_queue
+  connection pool by default on Ruby 3.2+.
+
+= Backwards Compatibility
+
+* Sequel now warns by default if using eager_graph/association_join
+  with an association that uses a block, in the cases where the
+  block would be ignored and there are no appropriate graph options
+  set. In Sequel 6, this warning will be turned into an exception.
+  It is recommended that users use the auto_restrict_eager_graph
+  plugin to turn this into an exception now, or use the
+  :graph_use_association_block option so that the block is not
+  ignored when graphing.

data/doc/testing.rdoc

@@ -159,12 +159,13 @@ The SEQUEL_INTEGRATION_URL environment variable specifies the Database connectio
 
 === Other
 
+SEQUEL_AUTO_CAST_DATE_TIME :: Use the auto_cast_date_and_time extension when running the specs
 SEQUEL_ASYNC_THREAD_POOL :: Use the async_thread_pool extension when running the specs
 SEQUEL_ASYNC_THREAD_POOL_PREEMPT :: Use the async_thread_pool extension when running the specs, with the :preempt_async_thread option
 SEQUEL_CHECK_PENDING :: Try running all specs (note, can cause lockups for some adapters), and raise errors for skipped specs that don't fail
 SEQUEL_COLUMNS_INTROSPECTION :: Use the columns_introspection extension when running the specs
 SEQUEL_CONCURRENT_EAGER_LOADING :: Use the async_thread_pool extension and concurrent_eager_loading plugin when running the specs
-SEQUEL_CONNECTION_VALIDATOR :: Use the connection validator extension when running the specs
+SEQUEL_CONNECTION_VALIDATOR :: Use the connection_validator extension when running the adapter/integration specs
 SEQUEL_DUPLICATE_COLUMNS_HANDLER :: Use the duplicate columns handler extension with value given when running the specs
 SEQUEL_ERROR_SQL :: Use the error_sql extension when running the specs
 SEQUEL_FIBER_CONCURRENCY :: Use the fiber_concurrency extension when running the adapter and integration specs
@@ -185,4 +186,5 @@ SEQUEL_QUERY_PER_ASSOCIATION_DB_2_URL :: Run query-per-association integration t
 SEQUEL_QUERY_PER_ASSOCIATION_DB_3_URL :: Run query-per-association integration tests with multiple databases (all 4 must be set to run)
 SEQUEL_SPLIT_SYMBOLS :: Turn on symbol splitting when running the adapter and integration specs
 SEQUEL_SYNCHRONIZE_SQL :: Use the synchronize_sql extension when running the specs
+SEQUEL_TRANSACTION_CONNECTION_VALIDATOR :: Use the transaction_connection_validator extension when running the adapter/integration specs
 SEQUEL_TZINFO_VERSION :: Force the given tzinfo version when running the specs (e.g. '>=2')

data/lib/sequel/adapters/jdbc/h2.rb

@@ -1,6 +1,7 @@
 # frozen-string-literal: true
 
 Sequel::JDBC.load_driver('org.h2.Driver', :H2)
+require_relative '../../extensions/auto_cast_date_and_time'
 
 module Sequel
   module JDBC
@@ -14,6 +15,8 @@ module Sequel
 
     module H2
       module DatabaseMethods
+        include AutoCastDateAndTime
+
         def commit_prepared_transaction(transaction_id, opts=OPTS)
           run("COMMIT TRANSACTION #{transaction_id}", opts)
         end

data/lib/sequel/adapters/jdbc/hsqldb.rb

@@ -2,6 +2,7 @@
 
 Sequel::JDBC.load_driver('org.hsqldb.jdbcDriver', :HSQLDB)
 require_relative 'transactions'
+require_relative '../../extensions/auto_cast_date_and_time'
 
 module Sequel
   module JDBC
@@ -15,6 +16,7 @@ module Sequel
 
     module HSQLDB
       module DatabaseMethods
+        include AutoCastDateAndTime
         include ::Sequel::JDBC::Transactions
 
         def database_type

data/lib/sequel/adapters/jdbc/sqlanywhere.rb

@@ -56,6 +56,17 @@ module Sequel
 
         private
 
+        # JDBC SQLAnywhere driver does not appear to handle fractional
+        # times correctly.
+        def default_time_format
+          "'%H:%M:%S'"
+        end
+
+        # Set to zero to work around JDBC SQLAnywhere driver bug.
+        def sqltime_precision
+          0
+        end
+
         SMALLINT_TYPE = Java::JavaSQL::Types::SMALLINT
         BOOLEAN_METHOD = Object.new
         def BOOLEAN_METHOD.call(r, i)

data/lib/sequel/adapters/mysql2.rb

@@ -182,8 +182,8 @@ module Sequel
             1
           when false
             0
-          when DateTime, Time
-            literal(arg)[1...-1]
+          when Time, Date
+            @default_dataset.literal_date_or_time(arg, true)
           else
             arg
           end

data/lib/sequel/adapters/odbc/mssql.rb

@@ -43,7 +43,7 @@ module Sequel
         # Use ODBC format, not Microsoft format, as the ODBC layer does
         # some translation, but allow for millisecond precision.
         def default_timestamp_format
-          "{ts '%Y-%m-%d %H:%M:%S%N'}"
+          "{ts '%Y-%m-%d %H:%M:%S.%3N'}"
         end
 
         # Use ODBC format, not Microsoft format, as the ODBC layer does

data/lib/sequel/adapters/postgres.rb

@@ -188,8 +188,8 @@ module Sequel
         # :nocov:
         # Not covered by tests as tests use pg_extended_date_support
         # extension, which has basically the same code.
-        when DateTime, Time
-          literal(arg)
+        when Time, DateTime
+          @default_dataset.literal_date_or_time(arg)
         # :nocov:
         else
           arg

data/lib/sequel/adapters/shared/mssql.rb

@@ -932,7 +932,7 @@ module Sequel
       # since that is the format that is multilanguage and not
       # DATEFORMAT dependent.
       def default_timestamp_format
-        "'%Y-%m-%dT%H:%M:%S%N%z'"
+        "'%Y-%m-%dT%H:%M:%S.%3N'"
       end
 
       # Only include the primary table in the main delete clause

data/lib/sequel/adapters/shared/mysql.rb

@@ -929,6 +929,16 @@ module Sequel
         super if type == :truncate || @opts[:offset]
       end
 
+      # The strftime format to use when literalizing time (Sequel::SQLTime) values.
+      def default_time_format
+        db.supports_timestamp_usecs? ? super : "'%H:%M:%S'"
+      end
+
+      # The strftime format to use when literalizing timestamp (Time/DateTime) values.
+      def default_timestamp_format
+        db.supports_timestamp_usecs? ? super : "'%Y-%m-%d %H:%M:%S'"
+      end
+
       # Consider the first table in the joined dataset is the table to delete
       # from, but include the others for the purposes of selecting rows.
       def delete_from_sql(sql)

data/lib/sequel/adapters/shared/oracle.rb

@@ -1,6 +1,7 @@
 # frozen-string-literal: true
 
 require_relative '../utils/emulate_offset_with_row_number'
+require_relative '../../extensions/auto_cast_date_and_time'
 
 module Sequel
   module Oracle
@@ -326,6 +327,8 @@ module Sequel
     end
 
     module DatasetMethods
+      include AutoCastDateAndTime
+
       ROW_NUMBER_EXPRESSION = LiteralString.new('ROWNUM').freeze
       BITAND_PROC = lambda{|a, b| Sequel.lit(["CAST(BITAND(", ", ", ") AS INTEGER)"], a, b)}
 
@@ -623,7 +626,7 @@ module Sequel
 
       # The strftime format to use when literalizing the time.
       def default_timestamp_format
-        "TIMESTAMP '%Y-%m-%d %H:%M:%S%N %z'"
+        "'%Y-%m-%d %H:%M:%S.%6N %:z'"
       end
 
       def empty_from_sql
@@ -660,11 +663,6 @@ module Sequel
         super
       end
 
-      # Use a colon for the timestamp offset, since Oracle appears to require it.
-      def format_timestamp_offset(hour, minute)
-        sprintf("%+03i:%02i", hour, minute)
-      end
-
       # Oracle doesn't support empty values when inserting.
       def insert_supports_empty_values?
         false

data/lib/sequel/adapters/shared/postgres.rb

@@ -1092,6 +1092,14 @@ module Sequel
         sql << type
       end
 
+      # Consider lock or statement timeout errors as evidence that the table exists
+      # but is locked.
+      def _table_exists?(ds)
+        super
+      rescue DatabaseError => e    
+        raise e unless /canceling statement due to (?:statement|lock) timeout/ =~ e.message 
+      end
+    
       def alter_table_add_column_sql(table, op)
         "ADD COLUMN#{' IF NOT EXISTS' if op[:if_not_exists]} #{column_definition_sql(op)}"
       end
@@ -1505,7 +1513,11 @@ module Sequel
       # currently visible schemas.
       def filter_schema(ds, opts)
         expr = if schema = opts[:schema]
-          schema.to_s
+          if schema.is_a?(SQL::Identifier)
+            schema.value.to_s
+          else
+            schema.to_s
+          end
         else
           Sequel.function(:any, Sequel.function(:current_schemas, false))
         end
@@ -2138,10 +2150,14 @@ module Sequel
         server_version >= 90500
       end
 
+      # :nocov:
+
       # PostgreSQL supports timezones in literal timestamps
       def supports_timestamp_timezones?
+        # SEQUEL6: Remove
         true
       end
+      # :nocov:
 
       # PostgreSQL 8.4+ supports WINDOW clause.
       def supports_window_clause?
@@ -2261,6 +2277,11 @@ module Sequel
         raise(InvalidOperation, "Joined datasets cannot be truncated") if opts[:join]
       end
 
+      # The strftime format to use when literalizing the time.
+      def default_timestamp_format
+        "'%Y-%m-%d %H:%M:%S.%6N%z'"
+      end
+
       # Only include the primary table in the main delete clause
       def delete_from_sql(sql)
         sql << ' FROM '

data/lib/sequel/adapters/shared/sqlanywhere.rb

@@ -281,10 +281,6 @@ module Sequel
         false
       end
 
-      def supports_timestamp_usecs?
-        false
-      end
-
       def supports_window_clause?
         true
       end
@@ -378,6 +374,16 @@ module Sequel
 
       private
 
+      # SQLAnywhere only supports 3 digits after the decimal point for times.
+      def default_time_format
+        "'%H:%M:%S.%3N'"
+      end
+
+      # SQLAnywhere only supports 3 digits after the decimal point for timestamps.
+      def default_timestamp_format
+        "'%Y-%m-%d %H:%M:%S.%3N'"
+      end
+
       # Use 1 for true on Sybase
       def literal_true
         '1'

data/lib/sequel/adapters/shared/sqlite.rb

@@ -145,6 +145,11 @@ module Sequel
         sqlite_version >= 30608
       end
 
+      # SQLite 3.8.2+ supports the without rowid table constraint
+      def support_without_rowid?
+        sqlite_version >= 30802
+      end
+
       # Override the default setting for whether to use timezones in timestamps.
       # It is set to +false+ by default, as SQLite's date/time methods do not
       # support timezones in timestamps.
@@ -344,9 +349,17 @@ module Sequel
         ps
       end
 
-      # Support creating STRICT tables via :strict option
+      # Support creating STRICT AND/OR WITHOUT ROWID tables via :strict and :without_rowid options
       def create_table_sql(name, generator, options)
-        "#{super}#{' STRICT' if options[:strict]}"
+        if options[:strict] && options[:without_rowid]
+          "#{super} STRICT, WITHOUT ROWID"
+        elsif options[:strict]
+          "#{super} STRICT"
+        elsif options[:without_rowid]
+          "#{super} WITHOUT ROWID"
+        else
+          super
+        end
       end
 
       # SQLite support creating temporary views.
@@ -917,6 +930,11 @@ module Sequel
         500
       end
 
+      # The strftime format to use when literalizing the time.
+      def default_timestamp_format
+        db.use_timestamp_timezones? ? "'%Y-%m-%d %H:%M:%S.%6N%z'" : super
+      end
+
       # SQL fragment specifying a list of identifiers
       def identifier_list(columns)
         columns.map{|i| quote_identifier(i)}.join(', ')

data/lib/sequel/adapters/sqlite.rb

@@ -111,6 +111,18 @@ module Sequel
       #              static data that you do not want to modify
       # :timeout :: how long to wait for the database to be available if it
       #             is locked, given in milliseconds (default is 5000)
+      # :setup_regexp_function :: enable use of Regexp objects with SQL
+      #             'REGEXP' operator. If the value is :cached or "cached",
+      #             caches the generated regexps, which can result in a memory
+      #             leak if dynamic regexps are used.  If the value is a Proc,
+      #             it will be called with a string for the regexp and a string
+      #             for the value to compare, and should return whether the regexp
+      #             matches.
+      # :regexp_function_cache :: If setting +setup_regexp_function+ to +cached+, this
+      #             determines the cache to use.  It should either be a proc or a class, and it
+      #             defaults to +Hash+. You can use +ObjectSpace::WeakKeyMap+ on Ruby 3.3+ to
+      #             have the VM automatically remove regexps from the cache after they
+      #             are no longer used.
       def connect(server)
         opts = server_opts(server)
         opts[:database] = ':memory:' if blank_object?(opts[:database])
@@ -126,9 +138,7 @@ module Sequel
         connection_pragmas.each{|s| log_connection_yield(s, db){db.execute_batch(s)}}
 
         if typecast_value_boolean(opts[:setup_regexp_function])
-          db.create_function("regexp", 2) do |func, regexp_str, string|
-            func.result = Regexp.new(regexp_str).match(string) ? 1 : 0
-          end
+          setup_regexp_function(db, opts[:setup_regexp_function])
         end
         
         class << db
@@ -202,6 +212,35 @@ module Sequel
         @conversion_procs['datetime'] = @conversion_procs['timestamp'] = method(:to_application_timestamp)
         set_integer_booleans
       end
+
+      def setup_regexp_function(db, how)
+        case how
+        when Proc
+          # nothing
+        when :cached, "cached"
+          cache = @opts[:regexp_function_cache] || Hash
+          cache = cache.is_a?(Proc) ? cache.call : cache.new
+          how = if RUBY_VERSION >= '2.4'
+            lambda do |regexp_str, str|
+              (cache[regexp_str] ||= Regexp.new(regexp_str)).match?(str)
+            end
+          else
+            lambda do |regexp_str, str|
+              (cache[regexp_str] ||= Regexp.new(regexp_str)).match(str)
+            end
+          end
+        else
+          how = if RUBY_VERSION >= '2.4'
+            lambda{|regexp_str, str| Regexp.new(regexp_str).match?(str)}
+          else
+            lambda{|regexp_str, str| Regexp.new(regexp_str).match(str)}
+          end
+        end
+
+        db.create_function("regexp", 2) do |func, regexp_str, str|
+          func.result = how.call(regexp_str, str) ? 1 : 0
+        end
+      end
       
       # Yield an available connection.  Rescue
       # any SQLite3::Exceptions and turn them into DatabaseErrors.

data/lib/sequel/connection_pool.rb

@@ -70,8 +70,10 @@ class Sequel::ConnectionPool
       else
         pc = if opts[:single_threaded]
           opts[:servers] ? :sharded_single : :single
-        #elsif RUBY_VERSION >= '3.2' # SEQUEL6 or maybe earlier
-        #  opts[:servers] ? :sharded_timed_queue : :timed_queue
+        # :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/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)