sequel 5.58.0 → 5.78.0

data/lib/sequel/adapters/jdbc.rb

@@ -396,11 +396,16 @@ module Sequel
 
       def database_exception_sqlstate(exception, opts)
         if database_exception_use_sqlstates?
-          while exception.respond_to?(:cause)
-            exception = exception.cause
-            return exception.getSQLState if exception.respond_to?(:getSQLState)
-          end
+          _database_exception_sqlstate(exception, opts)
         end
+      end
+
+      def _database_exception_sqlstate(exception, opts)
+        16.times do
+          return exception.getSQLState if exception.respond_to?(:getSQLState)
+          break unless exception.respond_to?(:cause) && (exception = exception.cause)
+        end
+
         nil
       end
 
@@ -415,8 +420,7 @@ module Sequel
 
       # Raise a disconnect error if the SQL state of the cause of the exception indicates so.
       def disconnect_error?(exception, opts)
-        cause = exception.respond_to?(:cause) ? exception.cause : exception
-        super || (cause.respond_to?(:getSQLState) && cause.getSQLState =~ /^08/)
+        super || (_database_exception_sqlstate(exception, opts) =~ /^08/)
       end
 
       # Execute the prepared statement.  If the provided name is a

data/lib/sequel/adapters/mysql.rb

@@ -29,6 +29,21 @@ module Sequel
     end
     MYSQL_TYPES.freeze
 
+    RUBY_MYSQL_3 = !Mysql.respond_to?(:init)
+    RUBY_MYSQL_4 = RUBY_MYSQL_3 && ::Mysql::VERSION.to_i >= 4
+
+    if RUBY_MYSQL_3
+      class Adapter < ::Mysql
+        alias real_connect connect
+        alias use_result store_result
+        if RUBY_MYSQL_4
+          def initialize(**opts)
+            super(**opts.merge(:cast=>false))
+          end
+        end
+      end
+    end
+
     class Database < Sequel::Database
       include Sequel::MySQL::DatabaseMethods
       include Sequel::MySQL::MysqlMysql2::DatabaseMethods
@@ -72,7 +87,7 @@ module Sequel
       def connect(server)
         opts = server_opts(server)
 
-        if Mysql.respond_to?(:init)
+        if !RUBY_MYSQL_3
           conn = Mysql.init
           conn.options(Mysql::READ_DEFAULT_GROUP, opts[:config_default_group] || "client")
           conn.options(Mysql::OPT_LOCAL_INFILE, opts[:config_local_infile]) if opts.has_key?(:config_local_infile)
@@ -88,8 +103,8 @@ module Sequel
             conn.options(Mysql::OPT_CONNECT_TIMEOUT, connect_timeout)
           end
         else
-          # ruby-mysql 3 API
-          conn = Mysql.new
+          # ruby-mysql 3+ API
+          conn = Adapter.new
           # no support for default group
           conn.local_infile = opts[:config_local_infile] if opts.has_key?(:config_local_infile)
           if encoding = opts[:encoding] || opts[:charset]
@@ -101,10 +116,7 @@ module Sequel
           if connect_timeout = opts[:connect_timeout]
             conn.connect_timeout = connect_timeout
           end
-          conn.singleton_class.class_eval do
-            alias real_connect connect
-            alias use_result store_result
-          end
+          opts[:compress] = false
         end
 
         conn.ssl_set(opts[:sslkey], opts[:sslcert], opts[:sslca], opts[:sslcapath], opts[:sslcipher]) if opts[:sslca] || opts[:sslkey]

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/oracle.rb

@@ -312,6 +312,7 @@ module Sequel
               :char_used => column.char_used?,
               :char_size => column.char_size,
               :data_size => column.data_size,
+              :column_size => column.precision,
               :precision => column.precision,
               :scale => column.scale,
               :fsprecision => column.fsprecision,

data/lib/sequel/adapters/postgres.rb

@@ -5,6 +5,7 @@ require_relative 'shared/postgres'
 begin 
   require 'pg' 
 
+  # :nocov:
   Sequel::Postgres::PGError = PG::Error if defined?(PG::Error)
   Sequel::Postgres::PGconn = PG::Connection if defined?(PG::Connection)
   Sequel::Postgres::PGresult = PG::Result if defined?(PG::Result)
@@ -14,30 +15,40 @@ begin
     raise LoadError unless defined?(PGconn::CONNECTION_OK)
   end
 
-  Sequel::Postgres::USES_PG = true
   if defined?(PG::TypeMapByClass)
+  # :nocov:
     type_map = Sequel::Postgres::PG_QUERY_TYPE_MAP = PG::TypeMapByClass.new
     type_map[Integer] = PG::TextEncoder::Integer.new
     type_map[FalseClass] = type_map[TrueClass] = PG::TextEncoder::Boolean.new
     type_map[Float] = PG::TextEncoder::Float.new
   end
+
+  Sequel::Postgres::USES_PG = true
 rescue LoadError => e 
+  # :nocov:
   begin
-    require 'postgres-pr/postgres-compat'
-    Sequel::Postgres::USES_PG = false
+    require 'sequel/postgres-pr'
   rescue LoadError 
-    raise e 
+    begin
+      require 'postgres-pr/postgres-compat'
+    rescue LoadError 
+      raise e 
+    end 
   end 
+  Sequel::Postgres::USES_PG = false
+  # :nocov:
 end
 
 module Sequel
   module Postgres
-    if Sequel::Postgres::USES_PG
+    # :nocov:
+    if USES_PG
       # Whether the given sequel_pg version integer is supported.
       def self.sequel_pg_version_supported?(version)
         version >= 10617
       end
     end
+    # :nocov:
 
     # PGconn subclass for connection specific methods used with the
     # pg or postgres-pr driver.
@@ -45,7 +56,9 @@ module Sequel
       # The underlying exception classes to reraise as disconnect errors
       # instead of regular database errors.
       DISCONNECT_ERROR_CLASSES = [IOError, Errno::EPIPE, Errno::ECONNRESET]
+      # :nocov:
       if defined?(::PG::ConnectionBad)
+      # :nocov:
         DISCONNECT_ERROR_CLASSES << ::PG::ConnectionBad
       end
       DISCONNECT_ERROR_CLASSES.freeze
@@ -71,11 +84,14 @@ module Sequel
         # are SQL strings.
         attr_reader :prepared_statements
 
+      # :nocov:
         unless public_method_defined?(:async_exec_params)
           alias async_exec_params async_exec
         end
-      else
-        # Make postgres-pr look like pg
+      elsif !const_defined?(:CONNECTION_OK)
+        # Handle old postgres-pr
+        # sequel-postgres-pr already implements this API
+
         CONNECTION_OK = -1
 
         # Escape bytea values.  Uses historical format instead of hex
@@ -111,6 +127,7 @@ module Sequel
           alias cmd_tuples cmdtuples
         end 
       end
+      # :nocov:
       
       # Raise a Sequel::DatabaseDisconnectError if a one of the disconnect
       # error classes is raised, or a PGError is raised and the connection
@@ -168,8 +185,12 @@ module Sequel
         case arg
         when Sequel::SQL::Blob
           {:value=>arg, :type=>17, :format=>1}
-        when DateTime, Time
-          literal(arg)
+        # :nocov:
+        # Not covered by tests as tests use pg_extended_date_support
+        # extension, which has basically the same code.
+        when Time, DateTime
+          @default_dataset.literal_date_or_time(arg)
+        # :nocov:
         else
           arg
         end
@@ -204,7 +225,9 @@ module Sequel
             :sslmode => opts[:sslmode],
             :sslrootcert => opts[:sslrootcert]
           }.delete_if { |key, value| blank_object?(value) }
+          # :nocov:
           connection_params.merge!(opts[:driver_options]) if opts[:driver_options]
+          # :nocov:
           conn = Adapter.connect(opts[:conn_str] || connection_params)
 
           conn.instance_variable_set(:@prepared_statements, {})
@@ -212,6 +235,13 @@ module Sequel
           if receiver = opts[:notice_receiver]
             conn.set_notice_receiver(&receiver)
           end
+
+          # :nocov:
+          if conn.respond_to?(:type_map_for_queries=) && defined?(PG_QUERY_TYPE_MAP)
+          # :nocov:
+            conn.type_map_for_queries = PG_QUERY_TYPE_MAP
+          end
+        # :nocov:
         else
           unless typecast_value_boolean(@opts.fetch(:force_standard_strings, true))
             raise Error, "Cannot create connection using postgres-pr unless force_standard_strings is set"
@@ -226,12 +256,11 @@ module Sequel
             opts[:password]
           )
         end
+        # :nocov:
 
         conn.instance_variable_set(:@db, self)
-        if USES_PG && conn.respond_to?(:type_map_for_queries=) && defined?(PG_QUERY_TYPE_MAP)
-          conn.type_map_for_queries = PG_QUERY_TYPE_MAP
-        end
 
+        # :nocov:
         if encoding = opts[:encoding] || opts[:charset]
           if conn.respond_to?(:set_client_encoding)
             conn.set_client_encoding(encoding)
@@ -239,6 +268,7 @@ module Sequel
             conn.async_exec("set client_encoding to '#{encoding}'")
           end
         end
+        # :nocov:
 
         connection_configuration_sqls(opts).each{|sql| conn.execute(sql)}
         conn
@@ -265,7 +295,9 @@ module Sequel
         nil
       end
 
+      # :nocov:
       if USES_PG && Object.const_defined?(:PG) && ::PG.const_defined?(:Constants) && ::PG::Constants.const_defined?(:PG_DIAG_SCHEMA_NAME)
+      # :nocov:
         # Return a hash of information about the related PGError (or Sequel::DatabaseError that
         # wraps a PGError), with the following entries (any of which may be +nil+):
         #
@@ -316,7 +348,9 @@ module Sequel
         synchronize(opts[:server]){|conn| check_database_errors{_execute(conn, sql, opts, &block)}}
       end
 
+      # :nocov:
       if USES_PG
+      # :nocov:
         # +copy_table+ uses PostgreSQL's +COPY TO STDOUT+ SQL statement to return formatted
         # results directly to the caller.  This method is only supported if pg is the
         # underlying ruby driver.  This method should only be called if you want
@@ -509,8 +543,10 @@ module Sequel
       def adapter_initialize
         @use_iso_date_format = typecast_value_boolean(@opts.fetch(:use_iso_date_format, true))
         initialize_postgres_adapter
+        # :nocov:
         add_conversion_proc(17, method(:unescape_bytea)) if USES_PG
         add_conversion_proc(1082, TYPE_TRANSLATOR_DATE) if @use_iso_date_format
+        # :nocov:
         self.convert_infinite_timestamps = @opts[:convert_infinite_timestamps]
       end
 
@@ -520,19 +556,22 @@ module Sequel
       rescue => e
         raise_error(e, :classes=>database_error_classes)
       end
-
       # Set the DateStyle to ISO if configured, for faster date parsing.
       def connection_configuration_sqls(opts=@opts)
         sqls = super
+        # :nocov:
         sqls << "SET DateStyle = 'ISO'" if @use_iso_date_format
+        # :nocov:
         sqls
       end
 
+      # :nocov:
       if USES_PG
         def unescape_bytea(s)
           ::Sequel::SQL::Blob.new(Adapter.unescape_bytea(s))
         end
       end
+      # :nocov:
 
       DATABASE_ERROR_CLASSES = [PGError].freeze
       def database_error_classes
@@ -546,7 +585,9 @@ module Sequel
       end
 
       def database_exception_sqlstate(exception, opts)
+        # :nocov:
         if exception.respond_to?(:result) && (result = exception.result)
+        # :nocov:
           result.error_field(PGresult::PG_DIAG_SQLSTATE)
         end
       end
@@ -631,6 +672,7 @@ module Sequel
       #          cursor usage.
       # :rows_per_fetch :: The number of rows per fetch (default 1000).  Higher
       #                    numbers result in fewer queries but greater memory use.
+      # :skip_transaction :: Same as :hold, but :hold takes priority.
       #
       # Usage:
       #
@@ -656,7 +698,9 @@ module Sequel
         clone(:where=>Sequel.lit(['CURRENT OF '], Sequel.identifier(cursor_name)))
       end
 
+      # :nocov:
       if USES_PG
+      # :nocov:
         PREPARED_ARG_PLACEHOLDER = LiteralString.new('$').freeze
         
         # PostgreSQL specific argument mapper used for mapping the named
@@ -721,13 +765,13 @@ module Sequel
 
       # Use a cursor to fetch groups of records at a time, yielding them to the block.
       def cursor_fetch_rows(sql)
-        server_opts = {:server=>@opts[:server] || :read_only}
         cursor = @opts[:cursor]
-        hold = cursor[:hold]
+        hold = cursor.fetch(:hold){cursor[:skip_transaction]}
+        server_opts = {:server=>@opts[:server] || :read_only, :skip_transaction=>hold}
         cursor_name = quote_identifier(cursor[:cursor_name] || 'sequel_cursor')
         rows_per_fetch = cursor[:rows_per_fetch].to_i
 
-        db.public_send(*(hold ? [:synchronize, server_opts[:server]] : [:transaction, server_opts])) do 
+        db.transaction(server_opts) do 
           begin
             execute_ddl("DECLARE #{cursor_name} NO SCROLL CURSOR WITH#{'OUT' unless hold} HOLD FOR #{sql}", server_opts)
             rows_per_fetch = 1000 if rows_per_fetch <= 0
@@ -803,6 +847,7 @@ module Sequel
   end
 end
 
+# :nocov:
 if Sequel::Postgres::USES_PG && !ENV['NO_SEQUEL_PG']
   begin
     require 'sequel_pg'
@@ -814,3 +859,4 @@ if Sequel::Postgres::USES_PG && !ENV['NO_SEQUEL_PG']
   rescue LoadError
   end
 end
+# :nocov:

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

@@ -17,7 +17,7 @@ module Sequel
 
       # Doesn't work, due to security restrictions on MSysObjects
       #def tables
-      #  from(:MSysObjects).where(:Type=>1, :Flags=>0).select_map(:Name).map(&:to_sym)
+      #  from(:MSysObjects).where(Type: 1, Flags: 0).select_map(:Name).map(&:to_sym)
       #end
       
       # Access doesn't support renaming tables from an SQL query,
@@ -57,6 +57,14 @@ module Sequel
         DATABASE_ERROR_REGEXPS
       end
 
+      # Access's Byte type will accept much larger values,
+      # even though it only stores 0-255.  Do not set min/max
+      # values for the Byte type.
+      def column_schema_integer_min_max_values(column)
+        return if /byte/i =~ column[:db_type]
+        super
+      end
+
       def drop_index_sql(table, op)
         "DROP INDEX #{quote_identifier(op[:name] || default_index_name(table, op[:columns]))} ON #{quote_schema_table(table)}"
       end

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

@@ -215,6 +215,18 @@ module Sequel
         DATABASE_ERROR_REGEXPS
       end
 
+      DISCONNECT_SQL_STATES = %w'40003 08001 08003'.freeze
+      def disconnect_error?(exception, opts)
+        sqlstate = database_exception_sqlstate(exception, opts)
+
+        case sqlstate
+        when *DISCONNECT_SQL_STATES
+          true
+        else
+          super
+        end
+      end
+
       # DB2 has issues with quoted identifiers, so
       # turn off database quoting by default.
       def quote_identifiers_default

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

@@ -32,7 +32,7 @@ module Sequel
       #
       # Options:
       # :args :: Arguments to stored procedure.  For named arguments, this should be a
-      #          hash keyed by argument named.  For unnamed arguments, this should be an
+      #          hash keyed by argument name.  For unnamed arguments, this should be an
       #          array.  Output parameters to the function are specified using :output.
       #          You can also name output parameters and provide a type by using an
       #          array containing :output, the type name, and the parameter name.
@@ -246,6 +246,34 @@ module Sequel
         information_schema_tables('VIEW', opts)
       end
       
+      # Attempt to acquire an exclusive advisory lock with the given lock_id (which will
+      # be converted to a string). If successful, yield to the block, then release the advisory lock
+      # when the block exits.  If unsuccessful, raise a Sequel::AdvisoryLockError.
+      #
+      # Options:
+      # :wait :: Do not raise an error, instead, wait until the advisory lock can be acquired.
+      def with_advisory_lock(lock_id, opts=OPTS)
+        lock_id = lock_id.to_s
+        timeout = opts[:wait] ? -1 : 0
+        server = opts[:server]
+      
+        synchronize(server) do
+          begin
+            res = call_mssql_sproc(:sp_getapplock, :server=>server, :args=>{'Resource'=>lock_id, 'LockTimeout'=>timeout, 'LockMode'=>'Exclusive', 'LockOwner'=>'Session'})
+
+            unless locked = res[:result] >= 0
+                raise AdvisoryLockError, "unable to acquire advisory lock #{lock_id.inspect}"
+            end
+
+            yield
+          ensure
+            if locked
+              call_mssql_sproc(:sp_releaseapplock, :server=>server, :args=>{'Resource'=>lock_id, 'LockOwner'=>'Session'})
+            end
+          end
+        end
+      end
+
       private
       
       # Add CLUSTERED or NONCLUSTERED as needed
@@ -325,6 +353,11 @@ module Sequel
         false
       end
 
+      # MSSQL tinyint types are unsigned.
+      def column_schema_tinyint_type_is_unsigned?
+        true
+      end
+
       # Handle MSSQL specific default format.
       def column_schema_normalize_default(default, type)
         if m = /\A(?:\(N?('.*')\)|\(\((-?\d+(?:\.\d+)?)\)\))\z/.match(default)
@@ -399,10 +432,15 @@ module Sequel
       # Backbone of the tables and views support.
       def information_schema_tables(type, opts)
         m = output_identifier_meth
-        metadata_dataset.from(Sequel[:information_schema][:tables].as(:t)).
+        schema = opts[:schema]||'dbo'
+        tables = metadata_dataset.from(Sequel[:information_schema][:tables].as(:t)).
           select(:table_name).
-          where(:table_type=>type, :table_schema=>(opts[:schema]||'dbo').to_s).
+          where(:table_type=>type, :table_schema=>schema.to_s).
           map{|x| m.call(x[:table_name])}
+
+        tables.map!{|t| Sequel.qualify(m.call(schema).to_s, m.call(t).to_s)} if opts[:qualify]
+
+        tables
       end
 
       # Always quote identifiers in the metadata_dataset, so schema parsing works.
@@ -586,6 +624,18 @@ module Sequel
         end
       end
       
+      # For a dataset with custom SQL, since it may include ORDER BY, you
+      # cannot wrap it in a subquery.  Load entire query in this case to get
+      # the number of rows. In general, you should avoid calling this method
+      # on datasets with custom SQL.
+      def count(*a, &block)
+        if (@opts[:sql] && a.empty? && !block)
+          naked.to_a.length
+        else
+          super
+        end
+      end
+
       # Uses CROSS APPLY to join the given table into the current dataset.
       def cross_apply(table)
         join_table(:cross_apply, table)
@@ -596,6 +646,19 @@ module Sequel
         clone(:disable_insert_output=>true)
       end
 
+      # For a dataset with custom SQL, since it may include ORDER BY, you
+      # cannot wrap it in a subquery.  Run query, and if it returns any
+      # records, return true. In general, you should avoid calling this method
+      # on datasets with custom SQL.
+      def empty?
+        if @opts[:sql]
+          naked.each{return false}
+          true
+        else
+          super
+        end
+      end
+
       # MSSQL treats [] as a metacharacter in LIKE expresions.
       def escape_like(string)
         string.gsub(/[\\%_\[\]]/){|m| "\\#{m}"}
@@ -800,11 +863,10 @@ module Sequel
         if opts[:return] == :primary_key && !@opts[:output]
           output(nil, [SQL::QualifiedIdentifier.new(:inserted, first_primary_key)])._import(columns, values, opts)
         elsif @opts[:output]
-          statements = multi_insert_sql(columns, values)
-          ds = naked
-          @db.transaction(opts.merge(:server=>@opts[:server])) do
-            statements.map{|st| ds.with_sql(st)}
-          end.first.map{|v| v.length == 1 ? v.values.first : v}
+          # no transaction: our multi_insert_sql_strategy should guarantee
+          # that there's only ever a single statement.
+          sql = multi_insert_sql(columns, values)[0]
+          naked.with_sql(sql).map{|v| v.length == 1 ? v.values.first : v}
         else
           super
         end
@@ -898,7 +960,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

@@ -197,6 +197,41 @@ module Sequel
         renames.each{|from,| remove_cached_schema(from)}
       end
       
+      # Attempt to acquire an exclusive advisory lock with the given lock_id (which will be
+      # converted to a string).  If successful, yield to the block, then release the advisory lock
+      # when the block exits.  If unsuccessful, raise a Sequel::AdvisoryLockError.
+      #
+      #   DB.with_advisory_lock(1357){DB.get(1)}
+      #   # SELECT GET_LOCK('1357', 0) LIMIT 1
+      #   # SELECT 1 AS v LIMIT 1
+      #   # SELECT RELEASE_LOCK('1357') LIMIT 1
+      #
+      # Options:
+      # :wait :: Do not raise an error, instead, wait until the advisory lock can be acquired.
+      def with_advisory_lock(lock_id, opts=OPTS)
+        lock_id = lock_id.to_s
+        ds = dataset
+        if server = opts[:server]
+          ds = ds.server(server)
+        end
+
+        # MariaDB doesn't support negative values for infinite wait.  A wait of 34 years
+        # should be reasonably similar to infinity for this case.
+        timeout = opts[:wait] ? 1073741823 : 0
+      
+        synchronize(server) do |c|
+          begin
+            unless locked = ds.get{GET_LOCK(lock_id, timeout)} == 1
+              raise AdvisoryLockError, "unable to acquire advisory lock #{lock_id.inspect}"
+            end
+
+            yield
+          ensure
+            ds.get{RELEASE_LOCK(lock_id)} if locked
+          end
+        end
+      end
+
       private
       
       def alter_table_add_column_sql(table, op)
@@ -550,6 +585,20 @@ module Sequel
         end
       end
 
+      # Return nil if CHECK constraints are not supported, because
+      # versions that don't support check constraints don't raise
+      # errors for values outside of range.
+      def column_schema_integer_min_max_values(column)
+        super if supports_check_constraints?
+      end
+
+      # Return nil if CHECK constraints are not supported, because
+      # versions that don't support check constraints don't raise
+      # errors for values outside of range.
+      def column_schema_decimal_min_max_values(column)
+        super if supports_check_constraints?
+      end
+
       # Split DROP INDEX ops on MySQL 5.6+, as dropping them in the same
       # statement as dropping a related foreign key causes an error.
       def split_alter_table_op?(op)
@@ -632,7 +681,7 @@ module Sequel
       MATCH_AGAINST_BOOLEAN = ["MATCH ".freeze, " AGAINST (".freeze, " IN BOOLEAN MODE)".freeze].freeze
 
       Dataset.def_sql_method(self, :delete, %w'with delete from where order limit')
-      Dataset.def_sql_method(self, :insert, %w'insert ignore into columns values on_duplicate_key_update')
+      Dataset.def_sql_method(self, :insert, %w'insert ignore into columns values on_duplicate_key_update returning')
       Dataset.def_sql_method(self, :select, %w'with select distinct calc_found_rows columns from join where group having window compounds order limit lock')
       Dataset.def_sql_method(self, :update, %w'with update ignore table set where order limit')
 
@@ -760,6 +809,21 @@ module Sequel
         clone(:insert_ignore=>true)
       end
 
+      # Support insert select for associations, so that the model code can use
+      # returning instead of a separate query.
+      def insert_select(*values)
+        return unless supports_insert_select?
+        # Handle case where query does not return a row
+        server?(:default).with_sql_first(insert_select_sql(*values)) || false
+      end
+
+      # The SQL to use for an insert_select, adds a RETURNING clause to the insert
+      # unless the RETURNING clause is already present.
+      def insert_select_sql(*values)
+        ds = opts[:returning] ? self : returning
+        ds.insert_sql(*values)
+      end
+
       # Sets up the insert methods to use ON DUPLICATE KEY UPDATE
       # If you pass no arguments, ALL fields will be
       # updated with the new values.  If you pass the fields you
@@ -857,6 +921,11 @@ module Sequel
         true
       end
 
+      # MariaDB 10.5.0 supports INSERT RETURNING.
+      def supports_returning?(type)
+        (type == :insert && db.mariadb? && db.adapter_scheme != :jdbc) ? (db.server_version >= 100500) : false
+      end
+
       # MySQL 8+ supports SKIP LOCKED.
       def supports_skip_locked?
         !db.mariadb? && db.server_version >= 80000
@@ -895,6 +964,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)