sequel 5.70.0 → 5.80.0

data/doc/release_notes/5.78.0.txt

@@ -0,0 +1,67 @@
+= New Features
+
+* SQLite 3.45+ jsonb functions are now supported in the sqlite_json_ops
+  extension.  Similar to the postgres_json_ops extension, there are
+  now separate methods for dealing with json and jsonb types:
+
+    Sequel.sqlite_json_op(:column)  # json
+    Sequel.sqlite_jsonb_op(:column) # jsonb
+
+  Some methods that use json_* functions for json ops use jsonb_*
+  functions for jsonb ops:
+
+    jb = Sequel.sqlite_jsonb_op(:column)
+    jb.extract('$.a')    # jsonb_extract(column, '$.a')
+    jb.insert('$.a', 1)  # jsonb_insert(column, '$.a', 1)
+    jb.set('$.a', 1)     # jsonb_set(column, '$.a', 1)
+    jb.replace('$.a', 1) # jsonb_replace(column, '$.a', 1)
+    jb.remove('$.a')     # jsonb_remove(column, '$.a')
+    jb.patch('{"a":2}')  # jsonb_patch(column, '{"a":2}')
+
+  You can use the json and jsonb methods to convert jsonb to json
+  and json to jsonb, respectively.
+
+    jb.json              # json(column)
+
+  Use of the json method on jsonb types is important, because if you
+  want to be able to deal with the values in Ruby, you must convert
+  the jsonb value to json in the database before the database returns
+  the value.  Unlike PostgreSQL, SQLite will not convert the value
+  from jsonb to json on retrieval, and direct use of SQLite's jsonb
+  format is unsupported by SQLite as it is subject to change.
+
+* Database#with_advisory_lock is now supported on PostgreSQL, MySQL,
+  and Microsoft SQL Server. This supports advisory (explicit)
+  locking, using the database-specific APIs.  To work on all three
+  servers, lock ids should be integers in the signed 64-bit range.
+
+    DB.with_advisory_lock(1234) do
+      # do something
+    end
+
+  By default, an AdvisoryLockError is raised if the lock cannot be
+  immediately acquired.  You can use the :wait option to wait until
+  the lock can be acquired, instead of raising.
+
+    DB.with_advisory_lock(1234, wait: true) do
+      # do something
+    end
+
+* Migrator.run now supports a :use_advisory_lock option to use
+  advisory locks when running migrations, so that it does not
+  attempt to run the same migration more than once in the case
+  where multiple processes are running the migrator simultaneously.
+  It's probably best to avoid running the migrator in multiple
+  processes simultaneously instead of relying on this option.
+
+= Other Improvements
+
+* Database#values now supports chaining with compounds on
+  PostgreSQL.
+
+    DB.values([[1, 2]]).union(DB.values([[3, 4]]))
+    # SELECT * FROM (VALUES (1, 2) UNION (VALUES (3, 4))) AS t1
+
+* The internal hash used to store transaction metadata now uses
+  compare_by_identity, which is faster and avoids potential
+  issues if a driver implements connection object equality.

data/doc/release_notes/5.79.0.txt

@@ -0,0 +1,28 @@
+= New Features
+
+* Dataset#select_prepend has been added for prepending to the
+  currently selected columns:
+
+    DB[:table].select_prepend(:column)
+    # SELECT column, table.*
+
+  As not all databases support "SELECT column, *", select_prepend
+  qualifies wildcard selections to all tables referenced in the
+  query.
+
+  The only reason to use select_prepend is if you want the hashes
+  returned by Sequel to be in a specific order.  Otherwise, it is
+  better to use select_append.
+
+* On PostgreSQL, Sequel now supports an :unlogged_tables_default
+  Database option, which will default created tables to be UNLOGGED.
+  This can be useful to speedup testing in some cases, but it should
+  never be used in cases where data integrity is important.
+
+= Other Improvements
+
+* On PostgreSQL, Database#create_or_replace_view now supports the
+  :materialized option.  This allows for dropping an existing
+  materialized view and creating a new one with the same name
+  (PostgreSQL does not have native support for replacing materialized
+  views).

data/doc/release_notes/5.80.0.txt

@@ -0,0 +1,40 @@
+= New Features
+
+* A provenance dataset extension has been added. This extension makes
+  SQL queries include a comment describing how the dataset was built.
+  This can make debugging complex cases significantly easier. Here's
+  a simple example:
+
+    DB.extension :provenance
+
+    DB[:table].
+      select(:a).
+      where{b > 10}.
+      order(:c).
+      limit(10)
+      # SQL:
+      # SELECT a FROM table WHERE (b > 10) ORDER BY c LIMIT 10 --
+      #  -- Dataset Provenance
+      #  -- Keys:[:from] Source:(eval at bin/sequel:257):2:in `<main>'
+      #  -- Keys:[:select] Source:(eval at bin/sequel:257):3:in `<main>'
+      #  -- Keys:[:where] Source:(eval at bin/sequel:257):4:in `<main>'
+      #  -- Keys:[:order] Source:(eval at bin/sequel:257):5:in `<main>'
+      #  -- Keys:[:limit] Source:(eval at bin/sequel:257):6:in `<main>'
+
+  With the above example, it's obvious how the dataset is created, but
+  but in real applications, where datasets can be built from multiple
+  files, seeing where each dataset clone was made can be helpful.
+
+  The source listed will skip locations in the Ruby standard library
+  as well as Sequel itself.  Other locations can be skipped by
+  providing a Database :provenance_caller_ignore Regexp option:
+
+    DB.opts[:provenance_caller_ignore] = /\/gems\/library_name-/
+
+= Other Improvements
+
+* For dataset methods where Sequel can determine that the return
+  value would be equivalent to the receiver, Sequel now returns the
+  receiver.  This reduces the number of dataset allocations.
+
+* Sequel now supports Dataset#skip_locked on MariaDB 10.6+.

data/doc/schema_modification.rdoc

@@ -81,8 +81,8 @@ appropriate 64-bit integer type for the database you are using.
 
 === Column options
 
-When using the type name as method, the third argument is an options hash, and when using the +column+
-method, the fourth argument is the options hash.  The following options are supported:
+When using the type name as method, the second argument is an options hash, and when using the +column+
+method, the third argument is the options hash.  The following options are supported:
 
 :default :: The default value for the column.
 :index :: Create an index on this column. If given a hash, use the hash as the

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
@@ -176,7 +177,7 @@ SEQUEL_MODEL_PREPARED_STATEMENTS :: Use the prepared_statements plugin when runn
 SEQUEL_MODEL_THROW_FAILURES :: Use the throw_failures plugin when running the specs
 SEQUEL_NO_CACHE_ASSOCIATIONS :: Don't cache association metadata when running the specs
 SEQUEL_NO_PENDING :: Don't skip any specs, try running all specs (note, can cause lockups for some adapters)
-SEQUEL_PG_AUTO_PARAMETERIZE :: Use the pg_auto_parameterize extension when running the postgres specs
+SEQUEL_PG_AUTO_PARAMETERIZE :: Use the pg_auto_parameterize extension when running the postgres specs.  Value can be +in_array+ to test the pg_auto_parameterize_in_array extension, and +in_array_string+ to test the pg_auto_parameterize_in_array extension with the +:treat_in_string_list_as_text_array+ Database option set.
 SEQUEL_PG_TIMESTAMPTZ :: Use the pg_timestamptz extension when running the postgres specs
 SEQUEL_PRIMARY_KEY_LOOKUP_CHECK_VALUES :: Use the primary_key_lookup_check_values extension when running the adapter or integration specs
 SEQUEL_QUERY_PER_ASSOCIATION_DB_0_URL :: Run query-per-association integration tests with multiple databases (all 4 must be set to run)
@@ -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/ibmdb.rb

@@ -301,7 +301,7 @@ module Sequel
       end
 
       def database_exception_sqlstate(exception, opts)
-        exception.sqlstate
+        exception.sqlstate if exception.respond_to?(:sqlstate)
       end
 
       def dataset_class_default

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

@@ -199,6 +199,7 @@ module Sequel
           v.strftime("'%H:%M:%S#{sprintf(".%03d", (v.usec/1000.0).round)}'")
         end
 
+        INTEGER_TYPE = Java::JavaSQL::Types::INTEGER
         STRING_TYPE = Java::JavaSQL::Types::VARCHAR
         ARRAY_TYPE = Java::JavaSQL::Types::ARRAY
         PG_SPECIFIC_TYPES = [Java::JavaSQL::Types::ARRAY, Java::JavaSQL::Types::OTHER, Java::JavaSQL::Types::STRUCT, Java::JavaSQL::Types::TIME_WITH_TIMEZONE, Java::JavaSQL::Types::TIME].freeze
@@ -219,6 +220,8 @@ module Sequel
             oid = meta.getField(i).getOID
             if pr = db.oid_convertor_proc(oid)
               pr
+            elsif oid == 28 # XID (Transaction ID)
+              map[INTEGER_TYPE]
             elsif oid == 2950 # UUID
               map[STRING_TYPE]
             elsif meta.getPGType(i) == 'hstore'

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

@@ -36,6 +36,10 @@ module Sequel
 
         private
 
+        def database_exception_use_sqlstates?
+          false
+        end
+
         # Use @@IDENTITY to get the last inserted id
         def last_insert_id(conn, opts=OPTS)
           statement(conn) do |stmt|
@@ -52,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/jdbc/sqlserver.rb

@@ -79,6 +79,10 @@ module Sequel
           super.with_extend(MetadataDatasetMethods)
         end
 
+        def database_exception_use_sqlstates?
+          false
+        end
+
         def disconnect_error?(exception, opts)
           super || (exception.message =~ /connection is closed/)
         end

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/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
@@ -672,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:
       #
@@ -764,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

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
@@ -932,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)
@@ -646,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')
 
@@ -774,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
@@ -871,9 +921,14 @@ module Sequel
         true
       end
 
-      # MySQL 8+ supports SKIP LOCKED.
+      # 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+ and MariaDB 10.6+ support SKIP LOCKED.
       def supports_skip_locked?
-        !db.mariadb? && db.server_version >= 80000
+        db.server_version >= (db.mariadb? ? 100600 : 80000)
       end
 
       # Check the database setting for whether fractional timestamps
@@ -909,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)

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