sequel 5.58.0 → 5.78.0

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/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/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
@@ -377,7 +377,7 @@ Sequel will not add a column, but will add a composite primary key constraint:
 It is possible to specify a name for the primary key constraint: via the :name option:
 
   alter_table(:albums_artists) do
-    add_primary_key [:album_id, :artist_id], :name=>:albums_artists_pkey
+    add_primary_key [:album_id, :artist_id], name: :albums_artists_pkey
   end
 
 If you just want to take an existing single column and make it a primary key, call

data/doc/security.rdoc

@@ -127,8 +127,8 @@ a ruby string as raw SQL.  For example:
   DB.literal(Date.today) # "'2013-03-22'"
   DB.literal('a') # "'a'"
   DB.literal(Sequel.lit('a')) # "a"
-  DB.literal(:a => 'a') # "(\"a\" = 'a')"
-  DB.literal(:a => Sequel.lit('a')) # "(\"a\" = a)"
+  DB.literal(a: 'a') # "(\"a\" = 'a')"
+  DB.literal(a: Sequel.lit('a')) # "(\"a\" = a)"
 
 ==== SQL Filter Fragments
 
@@ -178,7 +178,7 @@ user input for function names.
 For backwards compatibility, Sequel supports regular strings in the
 window function :frame option, which will be treated as a literal string:
 
-  DB[:table].select{fun(arg).over(:frame=>'SQL Here')}
+  DB[:table].select{fun(arg).over(frame: 'SQL Here')}
 
 You should make sure the frame argument is not derived from user input,
 or switch to using a hash as the :frame option value.
@@ -237,7 +237,7 @@ or:
 
 Instead, you should do:
 
-  DB[:table].update(:column => params[:value].to_s) # Safe
+  DB[:table].update(column: params[:value].to_s) # Safe
 
 Because using the auto_literal_strings extension makes SQL injection
 so much eaiser, it is recommended to not use it, and instead
@@ -402,29 +402,29 @@ This issue isn't necessarily specific to Sequel, but it is a good general practi
 If you are using values derived from user input, it is best to be explicit about
 their type.  For example:
 
-  Album.where(:id=>params[:id])
+  Album.where(id: params[:id])
 
 is probably a bad idea.  Assuming you are using a web framework, <tt>params[:id]</tt> could
 be a string, an array, a hash, nil, or potentially something else.
 
 Assuming that +id+ is an integer field, you probably want to do:
 
-  Album.where(:id=>params[:id].to_i)
+  Album.where(id: params[:id].to_i)
 
 If you are looking something up by name, you should try to enforce the value to be
 a string:
 
-  Album.where(:name=>params[:name].to_s)
+  Album.where(name: params[:name].to_s)
 
 If you are trying to use an IN clause with a list of id values based on input provided
 on a web form:
 
-  Album.where(:id=>params[:ids].to_a.map(&:to_i))
+  Album.where(id: params[:ids].to_a.map(&:to_i))
 
 Basically, be as explicit as possible. While there aren't any known security issues
 in Sequel when you do:
 
-  Album.where(:id=>params[:id])
+  Album.where(id: params[:id])
 
 It allows the attacker to choose to do any of the following queries:
 

data/doc/sharding.rdoc

@@ -39,7 +39,9 @@ is the simplest configuration:
     servers: {read_only: {host: 'replica_server'}})
 
 This will use the replica_server for SELECT queries and primary_server for
-other queries.
+other queries. The :read_only key in the :servers hash is special in that
+it sets the default database for Dataset methods that use SELECT queries
+(which are generally read queries that do not modify the database).
 
 If you want to ensure your queries are going to a specific database, you
 can force this for a given query by using the .server method and passing 

data/doc/sql.rdoc

@@ -59,7 +59,7 @@ Then, you call the +insert+, +update+, or +delete+ method on the returned datase
   update_ds.update
   delete_ds.delete
 
-+update+ and +delete+ should return the number of rows affected, and +insert+ should return the autogenerated primary key integer for the row inserted (if any).
++update+ and +delete+ generally return the number of rows affected, and +insert+ generally returns the autogenerated primary key integer for the row inserted (if any), but not all adapters/databases support this behavior for datasets using custom SQL (notably it is not supported for +insert+ on PostgreSQL).
 
 === Other Queries
 
@@ -223,22 +223,22 @@ If the database supports window functions, Sequel can handle them by calling the
   DB[:albums].select{count.function.*.over}
   # SELECT count(*) OVER () FROM albums
 
-  DB[:albums].select{function(:col1).over(:partition=>col2, :order=>col3)}
+  DB[:albums].select{function(:col1).over(partition: col2, order: col3)}
   # SELECT function(col1) OVER (PARTITION BY col2 ORDER BY col3) FROM albums
 
-  DB[:albums].select{function(c1, c2).over(:partition=>[c3, c4], :order=>[c5, c6.desc])}
+  DB[:albums].select{function(c1, c2).over(partition: [c3, c4], order: [c5, c6.desc])}
   # SELECT function(c1, c2) OVER (PARTITION BY c3, c4 ORDER BY c5, c6 DESC) FROM albums
 
-  DB[:albums].select{function(c1).over(:partition=>c2, :order=>:c3, :frame=>:rows)}
+  DB[:albums].select{function(c1).over(partition: c2, order: :c3, frame: :rows)}
   # SELECT function(c1) OVER (PARTITION BY c2 ORDER BY c3 ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) FROM albums
 
-  DB[:albums].select{function(c1).over(:partition=>c2, :order=>:c3, :frame=>{:type=>:range, :start=>1, :end=>1})}
+  DB[:albums].select{function(c1).over(partition: c2, order: :c3, frame: {type: :range, start: 1, end: 1})}
   # SELECT function(c1) OVER (PARTITION BY c2 ORDER BY c3 RANGE BETWEEN 1 PRECEDING AND 1 FOLLOWING) FROM albums
 
-  DB[:albums].select{function(c1).over(:partition=>c2, :order=>:c3, :frame=>{:type=>:groups, :start=>[2, :preceding], :end=>[1, :preceding]})}
+  DB[:albums].select{function(c1).over(partition: c2, order: :c3, frame: {type: :groups, start: [2, :preceding], end: [1, :preceding]})}
   # SELECT function(c1) OVER (PARTITION BY c2 ORDER BY c3 GROUPS BETWEEN 2 PRECEDING AND 1 PRECEDING) FROM albums
 
-  DB[:albums].select{function(c1).over(:partition=>c2, :order=>:c3, :frame=>{:type=>:range, :start=>:preceding, :exclude=>:current})}
+  DB[:albums].select{function(c1).over(partition: c2, order: :c3, frame: {type: :range, start: :preceding, exclude: :current})}
   # SELECT function(c1) OVER (PARTITION BY c2 ORDER BY c3 RANGE UNBOUNDED PRECEDING EXCLUDE CURRENT ROW) FROM albums
 
 === Schema Qualified Functions
@@ -551,8 +551,8 @@ You can also use the <tt>Sequel.asc</tt> and <tt>Sequel.desc</tt> methods:
 
 On some databases, you can specify null ordering:
 
-  Sequel.asc(:column, :nulls=>:first) # "column" ASC NULLS FIRST
-  Sequel.desc(Sequel[:table][:column], :nulls=>:last) # "table"."column" DESC NULLS LAST
+  Sequel.asc(:column, nulls: :first) # "column" ASC NULLS FIRST
+  Sequel.desc(Sequel[:table][:column], nulls: :last) # "table"."column" DESC NULLS LAST
 
 === All Columns (.*)
 
@@ -629,16 +629,16 @@ Also note that while the SELECT clause is displayed when you look at a dataset,
 
   ds = DB[:albums]
   ds.all # SELECT * FROM albums
-  ds.insert(:name=>'RF') # INSERT INTO albums (name) VALUES ('RF')
-  ds.update(:name=>'RF') # UPDATE albums SET name = 'RF'
+  ds.insert(name: 'RF') # INSERT INTO albums (name) VALUES ('RF')
+  ds.update(name: 'RF') # UPDATE albums SET name = 'RF'
   ds.delete # DELETE FROM albums
 
 In general, the +insert+, +update+, and +delete+ methods use the appropriate clauses you defined on the dataset:
 
-  ds = DB[:albums].where(:id=>1)
+  ds = DB[:albums].where(id: 1)
   ds.all # SELECT * FROM albums WHERE (id = 1)
-  ds.insert(:name=>'RF') # INSERT INTO albums (name) VALUES ('RF')
-  ds.update(:name=>'RF') # UPDATE albums SET name = 'RF' WHERE (id = 1)
+  ds.insert(name: 'RF') # INSERT INTO albums (name) VALUES ('RF')
+  ds.update(name: 'RF') # UPDATE albums SET name = 'RF' WHERE (id = 1)
   ds.delete # DELETE FROM albums WHERE (id = 1)
 
 Note how +update+ and +delete+ used the +where+ argument, but +insert+ did not, because INSERT doesn't use a WHERE clause.

data/doc/testing.rdoc

@@ -15,7 +15,7 @@ These run each test in its own transaction, the recommended way to test.
   
   class Minitest::HooksSpec
     def around
-      DB.transaction(:rollback=>:always, :auto_savepoint=>true){super}
+      DB.transaction(rollback: :always, auto_savepoint: true){super}
     end
   end
 
@@ -24,7 +24,7 @@ These run each test in its own transaction, the recommended way to test.
   
   class Minitest::Spec
     def run(*args, &block)
-      DB.transaction(:rollback=>:always, :auto_savepoint=>true){super}
+      DB.transaction(rollback: :always, auto_savepoint: true){super}
     end
   end
 
@@ -34,7 +34,7 @@ These run each test in its own transaction, the recommended way to test.
   # Use this class as the base class for your tests
   class SequelTestCase < Minitest::Test
     def run(*args, &block)
-      DB.transaction(:rollback=>:always, :auto_savepoint=>true){super}
+      DB.transaction(rollback: :always, auto_savepoint: true){super}
     end
   end
 
@@ -43,7 +43,7 @@ These run each test in its own transaction, the recommended way to test.
   
   RSpec.configure do |c|
     c.around(:each) do |example|
-      DB.transaction(:rollback=>:always, :auto_savepoint=>true){example.run}
+      DB.transaction(rollback: :always, auto_savepoint: true){example.run}
     end
   end
 
@@ -51,11 +51,11 @@ These run each test in its own transaction, the recommended way to test.
 
 You can use the Sequel.transaction method to run a transaction on multiple databases, rolling all of them back.  Instead of:
 
-  DB.transaction(:rollback=>:always)
+  DB.transaction(rollback: :always)
 
 Use Sequel.transaction with an array of databases:
 
-  Sequel.transaction([DB1, DB2, DB3], :rollback=>:always)
+  Sequel.transaction([DB1, DB2, DB3], rollback: :always)
 
 == Transactional testing with savepoints
 
@@ -71,11 +71,11 @@ Example:
   require 'minitest/hooks/default'
   class Minitest::HooksSpec
     def around
-      DB.transaction(:rollback=>:always, :savepoint=>true, :auto_savepoint=>true){super}
+      DB.transaction(rollback: :always, savepoint: true, auto_savepoint: true){super}
     end
 
     def around_all
-      DB.transaction(:rollback=>:always){super}
+      DB.transaction(rollback: :always){super}
     end
   end
 
@@ -159,28 +159,32 @@ 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_CONNECTION_VALIDATOR :: Use the connection validator extension when running the specs
-SEQUEL_DUPLICATE_COLUMNS_HANDLER :: Use the duplicate columns handler extension with value given 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 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_INDEX_CACHING :: Use the index_caching extension when running the specs
 SEQUEL_FIBER_CONCURRENCY :: Use the fiber_concurrency extension when running the adapter and integration specs
 SEQUEL_FREEZE_DATABASE :: Freeze the database before running the integration specs
 SEQUEL_IDENTIFIER_MANGLING :: Use the identifier_mangling extension when running the specs
+SEQUEL_INDEX_CACHING :: Use the index_caching extension when running the specs
 SEQUEL_INTEGER64 :: Use the integer64 extension when running the adapter or integration specs
 SEQUEL_MODEL_PREPARED_STATEMENTS :: Use the prepared_statements plugin when running the specs
 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_CHECK_PENDING :: Try running all specs (note, can cause lockups for some adapters), and raise errors for skipped specs that don't fail
 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.  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)
 SEQUEL_QUERY_PER_ASSOCIATION_DB_1_URL :: Run query-per-association integration tests with multiple databases (all 4 must be set to run)
 SEQUEL_QUERY_PER_ASSOCIATION_DB_2_URL :: Run query-per-association integration tests with multiple databases (all 4 must be set to run)
 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/doc/transactions.rdoc

@@ -127,28 +127,28 @@ Other exceptions, unless rescued inside the outer transaction block, will rollba
   end # ROLLBACK
   # ArgumentError raised
 
-If you want the current savepoint to be rolled back when the savepoint block exits instead of being committed (even if an exception is not raised), use <tt>Database#rollback_on_exit(:savepoint=>true)</tt>
+If you want the current savepoint to be rolled back when the savepoint block exits instead of being committed (even if an exception is not raised), use <tt>Database#rollback_on_exit(savepoint: true)</tt>
 
   DB.transaction do # BEGIN
     DB.transaction(savepoint: true) do # SAVEPOINT
-      DB.rollback_on_exit(:savepoint=>true)
+      DB.rollback_on_exit(savepoint: true)
     end # ROLLBACK TO SAVEPOINT
   end # COMMIT
 
   DB.transaction do # BEGIN
     DB.transaction(savepoint: true) do # SAVEPOINT
       DB.transaction(savepoint: true) do # SAVEPOINT
-        DB.rollback_on_exit(:savepoint=>true)
+        DB.rollback_on_exit(savepoint: true)
       end # ROLLBACK TO SAVEPOINT
     end # RELEASE SAVEPOINT
   end # COMMIT
 
-If you want the current savepoint and potentially enclosing savepoints to be rolled back when the savepoint blocks exit  (even if an exception is not raised), use <tt>Database#rollback_on_exit(:savepoint=>integer)</tt>
+If you want the current savepoint and potentially enclosing savepoints to be rolled back when the savepoint blocks exit  (even if an exception is not raised), use <tt>Database#rollback_on_exit(savepoint: integer)</tt>
 
   DB.transaction do # BEGIN
     DB.transaction(savepoint: true) do # SAVEPOINT
       DB.transaction(savepoint: true) do # SAVEPOINT
-        DB.rollback_on_exit(:savepoint=>2)
+        DB.rollback_on_exit(savepoint: 2)
       end # ROLLBACK TO SAVEPOINT
     end # ROLLBACK TO SAVEPOINT
   end # COMMIT
@@ -156,7 +156,7 @@ If you want the current savepoint and potentially enclosing savepoints to be rol
   DB.transaction do # BEGIN
     DB.transaction(savepoint: true) do # SAVEPOINT
       DB.transaction(savepoint: true) do # SAVEPOINT
-        DB.rollback_on_exit(:savepoint=>3)
+        DB.rollback_on_exit(savepoint: 3)
       end # ROLLBACK TO SAVEPOINT
     end # ROLLBACK TO SAVEPOINT
   end # ROLLBACK

data/doc/virtual_rows.rdoc

@@ -23,7 +23,7 @@ With virtual rows, you can use the less verbose:
 Virtual row blocks behave differently depending on whether the block accepts
 an argument.  If the block accepts an argument, it is called with an instance
 of Sequel::SQL::VirtualRow.  If it does not accept an argument, it is
-evaluated in the context of an instance of Sequel::SQL::VirtualRow.
+evaluated in the <em> context of an instance </em> of Sequel::SQL::VirtualRow.
 
   ds = DB[:items]
   # Regular block

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