sequel 4.36.0 → 5.61.0

data/doc/release_notes/5.16.0.txt

@@ -0,0 +1,110 @@
+= New Features
+
+* Database#rollback_on_exit has been added, which allows you to
+  rollback transactions instead of committing them when exiting
+  the transaction block.  Previously, the only way to rollback
+  a transaction from inside a transaction block was to raise
+  an exception.  This allows you to tell Sequel to roll the
+  transaction back on exit, and then use return or throw to exit
+  the transaction block.
+
+  Database#rollback_on_exit supports savepoints, including
+  multiple savepoint levels, as well as canceling rollbacks:
+
+    DB.transaction do # BEGIN
+      DB.rollback_on_exit
+    end # ROLLBACK
+  
+    DB.transaction do # BEGIN
+      DB.transaction(savepoint: true) do # SAVEPOINT
+        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)
+        end # ROLLBACK TO SAVEPOINT
+      end # RELEASE SAVEPOINT
+    end # COMMIT
+  
+    DB.transaction do # BEGIN
+      DB.transaction(savepoint: true) do # SAVEPOINT
+        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: 2)
+        end # ROLLBACK TO SAVEPOINT
+      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: 3)
+        end # ROLLBACK TO SAVEPOINT
+      end # ROLLBACK TO SAVEPOINT
+    end # ROLLBACK
+
+    DB.transaction do # BEGIN
+      DB.rollback_on_exit
+      DB.rollback_on_exit(cancel: true)
+    end # COMMIT
+  
+* Sequel now supports window functions on SQLite 3.26.0+. SQLite
+  technically supports window functions on 3.25.0+, but enabling
+  window function support in Sequel opens up a code path that
+  generates queries that cause older versions of SQLite to produce a
+  segmentation fault.  This bug in SQLite has been fixed in 3.26.0.
+
+= Other Improvements
+
+* Sequel::Model no longer overrides existing methods when defining
+  getters and setters.  Historically, it only checked for existing
+  method definitions for methods that could be directly expressed
+  (e.g. not requiring send).  Sequel 5 broke the check for setter
+  methods that could be directly expressed.  This fixes cases where
+  model inheritance is used and the setter methods are overridden
+  in a parent class.
+
+* Alter table emulation now works correctly on SQLite 3.26.0+.
+
+* The one_to_one association setter does not modify reciprocal
+  associations in cases where doing so is not necessary.  This can
+  fix some cases where the nested_attributes plugin is used.
+
+* The class_table_inheritance plugin can now take advantage of the
+  schema_caching extension to prevent database queries to determine
+  column information when the class is created.
+
+* The nested_attributes plugin no longer validates one_to_one
+  associations twice when saving.
+
+* The class_table_inheritance plugin :qualify_tables option now
+  correctly qualifies subclasses of subclasses.
+
+* SQL expressions that are subscripted are now wrapped in parentheses.
+  This fixes at least subscripting a function expression on
+  PostgreSQL:
+
+    DB[:t].select{array_agg(column).sql_subscript(1)}
+    # SELECT (array_agg(column))[1] FROM t
+
+* Sequel::Migrator now uses more descriptive error messages if a
+  missing or empty migration directory is given.
+
+* bin/sequel -C when converting from SQLite to another database
+  type will now use 64-bit integer columns in the other database when
+  the SQLite column type is integer, as SQLite supports storing
+  64-bit values in integer columns, and most other databases only
+  support 32-bit values in integer columns.
+
+= Backwards Compatibility
+
+* The mysql adapter no longer attempts to load the mysqlplus driver,
+  it now only attempts to load the mysql driver.

data/doc/release_notes/5.17.0.txt

@@ -0,0 +1,31 @@
+= New Features
+
+* An instance-level skip_auto_validations method has been added to
+  the auto_validations plugin, allowing you to skip all or specific
+  types of auto validations inside the block:
+
+    model_instance.skip_auto_validations(:unique) do
+      puts model_instance.valid?
+    end
+
+* A Database :preconnect_extensions option has been added.  This
+  option is similar to :extensions, but the extensions are loaded
+  before the :preconnect option is processed.  This allows you to
+  use the server_logging extension with the :preconnect option.
+
+* For specifying custom table aliases when using eager_graph and
+  association_join, you can now use:
+
+    Sequel[:association].as(:table_alias)
+
+  in addition to:
+
+    Sequel.as(:association, :table_alias)
+
+= Other Improvements
+
+* The ado/mssql adapter now retrieves the number of deleted or
+  updated rows for a query without issuing a separate query.
+
+* Sequel now avoids the use of Proc.new with an implicit block, as
+  that feature will be deprecated starting in Ruby 2.7.

data/doc/release_notes/5.18.0.txt

@@ -0,0 +1,69 @@
+= New Features
+
+* A throw_failures plugin has been added for throwing ValidationFailed
+  and HookFailed exceptions instead of raising them.  This can improve
+  performance by up to 10x on JRuby and 10-15% on CRuby.  However,
+  you would need to modify your exception handling from:
+
+    begin
+      # model.save
+    rescue Sequel::ValidationFailed => e
+      # handle failure
+    end
+
+  to:
+
+    e = catch(Sequel::ValidationFailed) do
+      # model.save
+    end
+    if e.is_a?(Sequel::ValidationFailed)
+      # handle failure
+    end
+
+  The throw_failures plugin will still work if you are not catching
+  the exception, falling back to the default behavior of raising
+  the exception.
+
+* SQL::Blob.call has been added, so that SQL::Blob can be used
+  directly as a callable to create a new instance, resulting in
+  better performance in cases where a callable is needed.
+
+= Other Improvements
+
+* Type conversion is many adapters is now faster by switching from
+  Proc/Method instances to using singleton call methods on plain
+  objects.  This can improve performance of row fetching by up to
+  10% in some cases.
+
+* Row fetching is slightly faster in the jdbc and sqlite adapters,
+  by switching from each to while.
+
+* tzinfo 2 is now supported when using the named_timezones extension.
+  tzinfo 1 remains supported.
+
+* The optimized Dataset#paged_each methods in the postgres and mysql2
+  adapters now support being called without a block, returning an
+  Enumerator in that case, to mirror the behavior of the default
+  Dataset#paged_each method.
+
+* Sequel no longer uses flow-control exceptions in the
+  connection_expiration and connection_validator extensions,
+  significantly improving performance on JRuby.
+
+* The after_initialize plugin no longer makes the argument to
+  Model.call optional.
+
+= Backwards Compatibility
+
+* Some internal by not private constants and methods previously used
+  for type conversion in adapters have been removed:
+
+  * JDBC::Oracle.OracleDecimal
+  * JDBC::Oracle.OracleClob
+  * JDBC::Postgres.RubyPGArray
+  * JDBC::Postgres.RubyPGHstore
+  * JDBC::SqlAnywhere.SqlAnywhereBoolean
+  * JDBC::SQLServer.MSSQLRubyTime
+  * MySQL::TYPE_TRANSLATOR
+  * Postgres::TYPE_TRANSLATOR
+

data/doc/release_notes/5.19.0.txt

@@ -0,0 +1,28 @@
+= New Features
+
+* A Database#rename_enum_value method has been added to the pg_enum
+  extension. It is supported on PostgreSQL 10+:
+
+    DB.rename_enum_value(:enum_type, 'old_name', 'new_name')
+
+= Other Improvements
+
+* The performance of row fetching and type conversion in the
+  sqlanywhere adapter has been improved.
+
+* The performance of row fetching in the sqlite adapter has been
+  improved.
+
+* Calling Database#drop_table now drops any constraint validations
+  metadata for the table if using the constraint_validations
+  extension.  However, modifying the table using Database#alter_table
+  does not affect the constraint validations metadata.
+
+* The sqlite adapter when used with ruby-sqlite3 1.4.0+ now uses
+  SQLite extended result codes for a more accurate determination of
+  specific database errors types.
+
+* Performance for typecasting to decimal and floats has been improved
+  slightly.
+
+* Performance when merging hashes has been improved slightly.

data/doc/release_notes/5.2.0.txt

@@ -0,0 +1,33 @@
+= New Features
+
+* A pg_extended_date_support extension has been added.  This
+  extension adds support for infinite and BC dates/timestamps on
+  PostgreSQL.
+
+  The postgres adapter already had a convert_infinite_timestamps
+  setting, but it wasn't supported in the jdbc/postgresql adapter
+  and it didn't handle BC dates/timestamps.  Setting a non-default
+  convert_infinite_timestamps setting in the postgres adapter will
+  now automatically load the extension for backwards compatibility.
+
+  The pg_extended_date_support extension by default just fixes the
+  handling of BC dates/timestamps.  To get it to handle infinite
+  timestamps, you need to choose the appropriate setting for your
+  application:
+
+    DB.extension :pg_extended_date_support
+    DB.convert_infinite_timestamps = :string # or :float or :nil
+
+  This extension also enables the handling of timezone offsets
+  with seconds, which is not natively supported by ruby's Time
+  class in ruby <2.5.
+
+= Improvements
+
+* The jdbc/mysql adapter now handles smallint unsigned and
+  integer unsigned column types where the value for the column
+  is outside of the range of a Java short or integer.
+
+* Sequel::Model.inherited no longer modifies an existing @dataset
+  instance variable if one has already been set.  This fixes a
+  regression that was introduced in Sequel 5.0.0.

data/doc/release_notes/5.20.0.txt

@@ -0,0 +1,89 @@
+= New Features
+
+* Database#after_commit and #after_rollback transaction hook methods
+  now support a :savepoint option.  Using the :savepoint option makes
+  the hooks savepoint-aware, so after_commit will only be called if
+  all enclosing savepoints and the transaction are committed, and
+  after_rollback will be called when any of the enclosing savepoints
+  are rolled back (which may be before transaction commit/rollback).
+  Examples:
+
+    x = nil
+    DB.transaction do # BEGIN
+      DB.transaction(savepoint: true) do # SAVEPOINT
+        DB.after_commit(savepoint: true){x = 1}
+        DB.after_rollback(savepoint: true){x = 2}
+        x # nil
+      end # RELEASE SAVEPOINT
+      x # nil
+    end # COMMIT
+    x # 1
+
+    x = nil
+    DB.transaction do  # BEGIN
+      DB.transaction(savepoint: true) do # SAVEPOINT
+        DB.after_commit(savepoint: true){x = 1}
+        DB.after_rollback(savepoint: true){x = 2}
+        x # nil
+        raise Sequel::Rollback
+      end # ROLLBACK TO SAVEPOINT
+      x # 2
+    end # COMMIT
+    x # 2
+  
+    x = nil
+    DB.transaction do # BEGIN
+      DB.transaction(savepoint: true) do # SAVEPOINT
+        DB.after_commit(savepoint: true){x = 1}
+        DB.after_rollback(savepoint: true){x = 2}
+      end # RELEASE SAVEPOINT
+      x # nil
+      raise Sequel::Rollback
+    end
+    x # 2
+
+* The pg_auto_constraint_validations plugin now supports a
+  pg_auto_constraint_validation_override method for overriding
+  the columns and message for a specific constraint.  This is
+  useful if the database cannot determine the columns (due
+  to the constraint containing a database function call), or
+  if you would like to customize the message per constraint.
+
+= Other Improvements
+
+* The one_to_one association setter now works with models that use
+  joined datasets, such as child models when using the
+  class_table_inheritance plugin.
+
+* Database#check_constraints on PostgreSQL now also includes CHECK
+  constraints where the related columns are not known.  The :columns
+  entry in the hash will be an empty array in such cases.  The
+  exclusion of such constraints in previous versions was not
+  intentional, and the documentation implied that all CHECK
+  constraints were returned.
+
+* Many cases where instance_exec was previously used on model
+  instances have been changed so that instance methods are defined
+  and called instead.  This avoids the creation of singleton classes
+  for model instances, and can significantly improve performance in
+  some cases.  This affects all associations as well as the
+  following plugins:
+
+  * composition
+  * hook_class_methods
+  * validation_class_methods
+
+  Other cases where instance_exec is now avoided and a different
+  approach is used:
+
+  * association_dependencies plugin
+  * PlaceholderLiteralString#with_dataset
+
+* The auto_validations plugin now works with child models when using
+  the class_table_inheritance plugin.
+
+* Database#server_version now works correctly in the mysql2 adapter
+  when using the MySQL driver with MariaDB 10+.
+
+* The float unsigned type is now recognized and supported in the
+  schema parser and schema_dumper extension.

data/doc/release_notes/5.21.0.txt

@@ -0,0 +1,87 @@
+= New Features
+
+* The pg_json extension now adds a Database#wrap_json_primitives
+  accessor.  When set to true, JSON primitive values (string, number,
+  true, false, and null) will be wrapped by delegate Ruby objects
+  instead of using Ruby primitives.  This allows the values to round
+  trip, so the following code will work even for primitive values in
+  json_column:
+
+    DB.extension :pg_json
+    DB.wrap_json_primitives = true
+    value = DB[:table].get(:json_column)
+    DB[:other_table].insert(json_column: value)
+
+  This should be enabled with care, especially in cases where false
+  and null JSON values are used, as the behavior will change if
+  the objects are used in a boolean context in Ruby, as only false
+  and nil in Ruby are treated as false:
+
+    # assume JSON false or null value
+    value = DB[:table].get(:json_column)
+
+    if value
+      # executed if wrap_json_primitives is true
+    else
+      # executed by default
+    end
+
+  When typecasting input in model objects to a JSON type, string
+  input will still be parsed as JSON.  However, you can set the
+  Database#typecast_json_strings accessor to true, and then string
+  input will be considered as a JSON string instead of parsing the
+  string as JSON.
+
+  To prevent backwards compatibility issues, Sequel.pg_json/pg_jsonb
+  behavior has not changed.  To support wrapping Ruby primitives in
+  the delegate objects, new Sequel.pg_json_wrap/pg_jsonb_wrap methods
+  have been added.  These methods only handle the Ruby primitives,
+  they cannot be used if the existing object is already a delegate
+  object.
+
+  As model objects always consider a nil value as SQL NULL and do
+  not typecast it, if you want to explicitly set a JSON null value,
+  you need to wrap it explicitly:
+
+    model_object.json_column = Sequel.pg_json_wrap(nil)
+
+= Other Improvements
+
+* Sequel now supports window function options :window, :exclude, and
+  :frame :type=>:groups, :start, and :end on SQLite 3.28.0+.
+
+* The server_block extension now respects the :servers_hash Database
+  option.  This makes it more similar to Sequel's default behavior.
+  However, that means by default, the server_block extension will
+  default to handling unknown shards as the default shard, instead
+  of raising an error for them.
+
+* The rcte_tree plugin now disallows eager graphing of the ancestors
+  and descendants associations.  Previously, eager graphing of these
+  associations generated incorrect results.  It is not possible to
+  eager graph these extensions, but normal eager loading does work.
+
+* The ado adapter's performance has been improved by using faster
+  callables for type conversion and a more efficient inner loop.
+
+* The sqlite adapter now converts a :timeout option given as a string
+  to an integer.  This allows you to use the option inside of a
+  connection string.
+
+* The mysql and mysql2 adapters now recognize an additional
+  DatabaseLockTimeout error.
+
+* The jdbc/mysql adapter now works correctly when using JRuby with
+  Java 11.
+
+* The ado adapter now handles numeric values when using locales that
+  use comma instead of period as the decimal separator.
+
+= Backwards Compatibility
+
+* In the pg_json extension, the following singleton methods of
+  Sequel::Postgres::JSONDatabaseMethods are now deprecated:
+
+  * parse_json
+  * db_parse_json
+  * db_parse_jsonb 

data/doc/release_notes/5.22.0.txt

@@ -0,0 +1,48 @@
+= New Features
+
+* Sequel now supports Ruby 2.7+ startless ranges in filters:
+
+    DB[:table].where(:column=>(..10))
+    # SELECT * FROM table WHERE (column <= 10)
+
+    DB[:table].where(:column=>(...10))
+    # SELECT * FROM table WHERE (column < 10)
+
+  It also supports startless, endless ranges in filters, using a
+  condition that is always true:
+
+    DB[:table].where(:column=>(nil..nil))
+    # SELECT * FROM table WHERE (1 = 1)
+
+* Sequel now supports startless ranges in the pg_range extension:
+
+    DB.extension :pg_range
+
+    DB[:table].insert(:column=>(..10))
+    # INSERT INTO "table" ("column") VALUES ('[,10]') RETURNING "id"
+
+    DB[:table].insert(:column=>(...10))
+    # INSERT INTO "table" ("column") VALUES ('[,10)') RETURNING "id"
+
+    DB[:table].insert(:column=>(nil..nil))
+    # INSERT INTO "table" ("column") VALUES ('[,]') RETURNING "id"
+
+* Sequel now supports a :materialized option in Dataset#with on
+  PostgreSQL 12+, to control the inlining of common table expressions:
+
+    DB[:t].with(:t, DB[:t2], :materialized=>false)
+    # WITH "t" AS NOT MATERIALIZED (SELECT * FROM "t2")
+    # SELECT * FROM "t"
+
+    DB[:t].with(:t, DB[:t2], :materialized=>true)
+    # WITH "t" AS MATERIALIZED (SELECT * FROM "t2")
+    # SELECT * FROM "t"
+
+= Other Improvements
+
+* Database#primary_key_sequence now works for tables without serial
+  sequences on PostgreSQL 12+.
+
+* Dataset#multi_insert and #import with return: :primary_key option
+  on Microsoft SQL Server now work correctly if the dataset uses
+  a row_proc (e.g. for model datasets).

data/doc/release_notes/5.23.0.txt

@@ -0,0 +1,56 @@
+= New Features
+
+* An insert_conflict plugin has been added for automatically handling
+  constraint conflicts when saving new model instances.  It is
+  supported on PostgreSQL 9.5+ and SQLite 3.24.0+.
+
+    Album.new(name: 'Foo', copies_sold: 1000).
+      insert_conflict(
+        target: :name,
+        update: {copies_sold: Sequel[:excluded][:b]}
+      ).
+      save
+
+* On Microsoft SQL Server, the Database :ansi option has been added,
+  which sets the following ANSI related options:
+
+  * ANSI_NULLS
+  * ANSI_PADDING
+  * ANSI_WARNINGS
+  * ANSI_NULL_DFLT_ON
+  * QUOTED_IDENTIFIER
+  * CONCAT_NULL_YIELDS_NULL
+
+= Other Improvements
+
+* Sequel.datetime_class = Time is now supported when using the
+  named_timezones extension.  For backwards compatibility, the
+  named_timezones extension still sets
+  Sequel.datetime_class = DateTime.  When using Ruby 2.6+, the
+  Time instances have the timezone set on them using Ruby 2.6+'s
+  timezone support, but basic support works correctly in earlier
+  versions of Ruby.
+
+* On Microsoft SQL Server, Sequel now handles parsing schema for
+  tables in another database on the same server or in a database
+  on a linked server.
+
+* The pg_json extension now correctly handles subclasses of core
+  classes when wrapping objects.  This stopped working in Sequel
+  5.21.0, when support for wrapping JSON primitives was added.
+
+* Sequel now works around a couple bugs in jdbc-sqlite 3.27.2.1,
+  allowing schema parsing and foreign key parsing to work.
+
+* Dataset#execute* private methods now respect an explicitly given
+  :server option, fixing Dataset#paged_each in the postgres adapter
+  when using sharding.
+
+* Timezone offsets are now handled correctly when typecasting an array
+  or hash to datetime when Sequel.datetime_class = Time.
+
+* Sequel now avoids errors when parsing schema when using the mock
+  SQLite adapter.
+
+* A minor thread-safety issue has been fixed in the named_timezones
+  extension.

data/doc/release_notes/5.24.0.txt

@@ -0,0 +1,56 @@
+= New Features
+
+* A :cache_file plugin option has been added to the
+  pg_auto_constraint_validations plugin.  This option specifies
+  a file to use to cache the metadata the plugin uses, so the
+  plugin does not need to run 5 queries per model at startup to
+  load the metadata.  This can dramatically improve startup time
+  when using the plugin with a large number of models.
+
+  To create the metadata file, load the plugin into Sequel::Model
+  (or whatever class you are using as the base class for your
+  model classes) with the :cache_file option, and after loading
+  all of the subclasses of that class, run:
+
+    Sequel::Model.dump_pg_auto_constraint_validations_cache
+
+  As when using the schema_caching and index_caching extensions,
+  it is up to the user to ensure that the cached metadata matches
+  the current database schema.  Sequel does no checking of this,
+  as checking would take more time, and the point of this plugin
+  is to improve startup performance.
+
+* A static_cache_cache plugin has been added.  This plugin allows
+  for caching rows for models using the static_cache plugin. This
+  prevents the need to issue a query at model creation time to
+  get the rows.  This plugin should be loaded into Sequel::Model
+  (or whatever class you are using as the base class for your
+  model classes) before loading the models using the static_cache
+  plugin.  To create the metadata file, after all subclasses of
+  that class have been loaded, run:
+
+    Sequel::Model.dump_static_cache_cache
+
+* :unique_deferrable and :primary_key_deferrable column
+  options are now supported on PostgreSQL 9+ and Oracle. This
+  allows you to created deferrable unique and primary key
+  column constraints.  You could already create deferrable
+  table constraints using the :deferrable option to the primary_key
+  and unique methods.
+
+* A :generated_always_as column option is now supported on
+  PostgreSQL 12+, for creating generated columns.
+
+* A Database#skip_logging? private method has been added.  This
+  is designed for use in extensions, to force log timing even
+  when no loggers are configured.
+
+= Other Improvements
+
+* Sequel no longer sets the :host option to localhost by default
+  in the mysql2 adapter.  This prevents Sequel from overriding
+  a host specified in the defaults_file.
+
+* All database array types are converted to Ruby arrays in the
+  jdbc adapter.  Previously, this was only done in the
+  jdbc/postgresql subadapter.

data/doc/release_notes/5.25.0.txt

@@ -0,0 +1,32 @@
+= New Features
+
+* An association_multi_add_remove plugin has been added.  This plugin
+  adds a shortcut for adding or removing multiple associated objects
+  in a single method call:
+
+    Artist.plugin :association_multi_add_remove
+    Artist.many_to_one :albums
+    Artist[1].add_albums([Album[2], Album[3]])
+    Artist[1].remove_albums([Album[4], Album[5]])
+
+  It also offers a setter method, which will add and remove associated
+  objects as necessary:
+
+    Artist[1].albums = [Album[3], Album[4]]
+
+= Other Improvements
+
+* The sharding plugin now integrates with the server_block extension.
+  This makes it so if you retrieve a model instance inside a
+  with_server block, saving the model instance will save it back to
+  the shard from which it was retrieved.
+
+* Setting a default for a column on Microsoft SQL Server now works
+  correctly if the column already has a default.
+
+* Sequel::SQL::NumericMethods#coerce no longer raises NoMethodError
+  if the super method is not defined.  This fixes some cases when
+  comparing Date/DateTime instances to Sequel objects.
+
+* The csv_serializer plugin now avoids keyword argument separation
+  issues on Ruby 2.7+.

data/doc/release_notes/5.26.0.txt

@@ -0,0 +1,35 @@
+= New Features
+
+* Support for SQL/JSON path expressions has been added to the
+  pg_json_ops extension. These are supported in PostgreSQL 12+.
+  Examples:
+
+    j = Sequel.pg_json_op(:json_column)
+    j.path_exists('$.foo')      # (jsonb_column @? '$.foo')
+    j.path_match('$.foo')       # (jsonb_column @@ '$.foo')
+    j.path_exists!('$.foo')     # jsonb_path_exists(jsonb_column, '$.foo')
+    j.path_match!('$.foo')      # jsonb_path_match(jsonb_column, '$.foo')
+    j.path_query('$.foo')       # jsonb_path_query(jsonb_column, '$.foo')
+    j.path_query_array('$.foo') # jsonb_path_query_array(jsonb_column, '$.foo')
+    j.path_query_first('$.foo') # jsonb_path_query_first(jsonb_column, '$.foo')
+
+* The nested_attributes method in the nested_attributes plugin now
+  supports a :require_modification option, which can override the
+  default require_modification setting for the nested objects. This
+  can be useful to avoid errors if multiple requests are submitted
+  simultaneously to delete the same nested row.
+
+= Other Improvements
+
+* The dirty plugin now works correctly with the typecast_on_load
+  plugin.
+
+* Sequel::Postgres::PGRange#hash has been added to the pg_range
+  extension, allowing PGRange instances to be usable as hash keys.
+
+* Table aliases are now supported for single table INSERT
+  statements on PostgreSQL 9.5+, which can make some insert_conflict
+  usage easier.
+
+* Two more foreign key constraint violation types are now recognized
+  on MySQL 8.0.13+.