sequel 5.45.0 → 5.77.0

data/doc/opening_databases.rdoc

@@ -102,6 +102,7 @@ The following options can be specified and are passed to the database's internal
 :after_connect :: A callable object called after each new connection is made, with the
                   connection object (and server argument if the callable accepts 2 arguments),
                   useful for customizations that you want to apply to all connections (nil by default).
+:connect_sqls :: An array of sql strings to execute on each new connection, after :after_connect runs.
 :max_connections :: The maximum size of the connection pool (4 connections by default on most databases)
 :pool_timeout :: The number of seconds to wait if a connection cannot be acquired before raising an error (5 seconds by default)
 :single_threaded :: Whether to use a single-threaded (non-thread safe) connection pool
@@ -249,7 +250,7 @@ jdbc-mysql :: Depending on the configuration of the MySQL server, jdbc-mysql ver
 
 Requires: mysql
 
-The MySQL adapter does not support the pure-ruby mysql.rb driver, it requires the C-extension driver.
+This should work with the mysql gem (C extension) and the ruby-mysql gem (pure ruby).
 
 The following additional options are supported:
 
@@ -258,6 +259,8 @@ The following additional options are supported:
 :compress :: Whether to compress data sent/received via the socket connection.
 :config_default_group :: The default group to read from the in the MySQL config file, defaults to "client")
 :config_local_infile :: If provided, sets the Mysql::OPT_LOCAL_INFILE option on the connection with the given value.
+:disable_split_materialized :: Set split_materialized=off in the optimizer settings.  Necessary to pass the associations
+                               integration tests in MariaDB 10.5+, due to a unfixed bug in the optimizer.
 :encoding :: Specify the encoding/character set to use for the connection.
 :fractional_seconds :: On MySQL 5.6.5+, this option is recognized and will include fractional seconds in
                        time/timestamp values, as well as have the schema method create columns that can contain
@@ -265,7 +268,7 @@ The following additional options are supported:
                        to MySQL.
 :socket :: Can be used to specify a Unix socket file to connect to instead of a TCP host and port.
 :sql_mode :: Set the sql_mode(s) for a given connection.  Can be single symbol or string,
-             or an array of symbols or strings (e.g. <tt>:sql_mode=>[:no_zero_date, :pipes_as_concat]</tt>).
+             or an array of symbols or strings (e.g. <tt>sql_mode: [:no_zero_date, :pipes_as_concat]</tt>).
 :timeout :: Sets the wait_timeout for the connection, defaults to 1 month.
 :read_timeout :: Set the timeout in seconds for reading back results to a query.
 :connect_timeout :: Set the timeout in seconds before a connection attempt is abandoned
@@ -276,22 +279,24 @@ if either the :sslca or :sslkey option is given.
 
 === mysql2
 
-This is a newer MySQL adapter that does typecasting in C, so it is often faster than the
+This is a MySQL adapter that does typecasting in C, so it is often faster than the
 mysql adapter.  The options given are passed to Mysql2::Client.new, see the mysql2 documentation
-for details on what options are supported.
+for details on what options are supported. The :timeout, :auto_is_null, :sql_mode, and :disable_split_materialized
+options supported by the mysql adapter are also supported for mysql2 adapter (and any other adapters connecting to
+mysql, such as the jdbc/mysql adapter).
 
 === odbc 
 
 The ODBC adapter allows you to connect to any database with the appropriate ODBC drivers installed.  
 The :database option given ODBC database should be the DSN (Descriptive Service Name) from the ODBC configuration.
 
-  Sequel.odbc('mydb', :user => "user", :password => "password")
+  Sequel.odbc('mydb', user: "user", password: "password")
 
 The :host and :port options are not respected. The following additional options are supported:
 
 :db_type :: Can be specified as 'mssql', 'progress', or 'db2' to use SQL syntax specific to those databases.
 :drvconnect :: Can be given an ODBC connection string, and will use ODBC::Database#drvconnect to
-               do the connection.  Typical usage would be: <tt>Sequel.odbc(:drvconnect=>'driver={...};...')</tt>
+               do the connection.  Typical usage would be: <tt>Sequel.odbc(drvconnect: 'driver={...};...')</tt>
 
 === oracle 
 
@@ -307,15 +312,14 @@ The following additional options are supported:
 
 === postgres
 
-Requires: pg (or postgres-pr/postgres-compat if pg is not available)
+Requires: pg (or sequel/postgres-pr or postgres-pr/postgres-compat if pg is not available)
 
-The Sequel postgres adapter works with the pg and postgres-pr ruby libraries.
+The Sequel postgres adapter works with the pg, sequel-postgres-pr, jeremyevans-postgres-pr, and postgres-pr ruby libraries.
 The pg library is the best supported, as it supports real bound variables and prepared statements.
 If the pg library is being used, Sequel will also attempt to load the sequel_pg library, which is
 a C extension that optimizes performance when Sequel is used with pg.  All users of Sequel who
-use pg are encouraged to install sequel_pg.  For users who want to use postgres-pr to avoid issues
-with C extensions, it is recommended to use jeremyevans-postgres-pr, which fixes many issues in
-the upstream postgres-pr gem, and is regularly tested with Sequel.
+use pg are encouraged to install sequel_pg.  For users who want to use one of the postgres-pr
+libraries to avoid issues with C extensions, it is recommended to use sequel-postgres-pr.
 
 The following additional options are supported:
 
@@ -341,7 +345,7 @@ The following additional options are supported:
 :search_path :: Set to the schema search_path.  This can either be a single string containing the schemas
                 separated by commas (for use via a URL: <tt>postgres:///?search_path=schema1,schema2</tt>), or it
                 can be an array of strings (for use via an option:
-                <tt>Sequel.postgres(:search_path=>['schema1', 'schema2'])</tt>).
+                <tt>Sequel.postgres(search_path: ['schema1', 'schema2'])</tt>).
 :use_iso_date_format :: This can be set to false to not force the ISO date format.  Sequel forces
                         it by default to allow for an optimization.
 
@@ -383,6 +387,11 @@ The following additional options are supported:
 
 :readonly :: open database in read-only mode
 :timeout :: the busy timeout to use in milliseconds (default: 5000).
+:setup_regexp_function :: Whether to setup a REGEXP function in the underlying SQLite3::Database object. Doing so
+                          allows you to use regexp support in dataset expressions.  If +:cached+ or <tt>"cached"</tt>+, caches each
+                          unique regex (more efficient but risk of memory leak). If a Proc is provided, it will be called with
+                          a string for the regexp and a string for the value to compare, and should return whether the regexp
+                          string matches the string value to compare. The default Proc used does <tt>Regexp.new(regexp_str).match(str)</tt>.
 
 Note that SQLite memory databases are restricted to a single connection by
 default.  This is because SQLite does not allow multiple connections to
@@ -416,3 +425,10 @@ Other Sequel specific options:
              This should be specified as an integer.  If you plan on setting large
              text or blob values via tinytds, you should use this option or modify
              your freetds.conf file.
+
+=== trilogy
+
+This is a MySQL adapter that does typecasting in C, and does not require any mysql client libraries installed.
+The options given are passed to Trilogy.new, see the trilogy documentation for details on what options are
+supported. The :timeout, :auto_is_null, :sql_mode, and :disable_split_materialized
+options supported by the mysql adapter are also supported for trilogy adapter.

data/doc/postgresql.rdoc

@@ -295,16 +295,16 @@ option to +foreign_key_list+:
     primary_key :id
     Integer :i
     Integer :j
-    foreign_key :a_id, :a, :foreign_key_constraint_name=>:a_a
+    foreign_key :a_id, :a, foreign_key_constraint_name: :a_a
     unique [:i, :j]
   end
   DB.create_table!(:b) do
-    foreign_key :a_id, :a, :foreign_key_constraint_name=>:a_a
+    foreign_key :a_id, :a, foreign_key_constraint_name: :a_a
     Integer :c
     Integer :d
-    foreign_key [:c, :d], :a, :key=>[:j, :i], :name=>:a_c_d
+    foreign_key [:c, :d], :a, key: [:j, :i], name: :a_c_d
   end
-  DB.foreign_key_list(:a, :reverse=>true)
+  DB.foreign_key_list(:a, reverse: true)
   # => [
   #  {:name=>:a_a, :columns=>[:a_id], :key=>[:id], :on_update=>:no_action, :on_delete=>:no_action, :deferrable=>false, :table=>:a, :schema=>:public},
   #  {:name=>:a_a, :columns=>[:a_id], :key=>[:id], :on_update=>:no_action, :on_delete=>:no_action, :deferrable=>false, :table=>:b, :schema=>:public},
@@ -413,12 +413,12 @@ syntax:
 
   DB.create_table(:table){primary_key :id}
   # Ignore the given value for id, using the identity's sequence value.
-  DB[:table].overriding_user_value.insert(:id=>1)
+  DB[:table].overriding_user_value.insert(id: 1)
 
-  DB.create_table(:table){primary_key :id, :identity=>:always}
+  DB.create_table(:table){primary_key :id, identity: :always}
   # Force the use of the given value for id, because otherwise the insert will
   # raise an error, since GENERATED ALWAYS was used when creating the column.
-  DB[:table].overriding_system_value.insert(:id=>1)
+  DB[:table].overriding_system_value.insert(id: 1)
 
 === Distinct On Specific Columns
 
@@ -428,6 +428,14 @@ rows that are distinct on just those columns:
   DB[:table].distinct(:id).all
   # SELECT DISTINCT ON ("id") * FROM "table"
 
+=== JOIN USING table alias
+
+Sequel allows passing an SQL::AliasedExpression to join table methods to use a USING
+join with a table alias for the USING columns:
+
+  DB[:t1].join(:t2, Sequel.as([:c1, :c2], :alias))
+  # SELECT * FROM "t1" INNER JOIN "t2" USING ("c1", "c2") AS "alias"
+
 === Calling PostgreSQL 11+ Procedures <tt>postgres only</tt>
 
 PostgreSQL 11+ added support for procedures, which are different from the user defined
@@ -553,7 +561,7 @@ such as the related table and column or constraint.
 
   DB.create_table(:test1){primary_key :id}
   DB.create_table(:test2){primary_key :id; foreign_key :test1_id, :test1}
-  DB[:test2].insert(:test1_id=>1) rescue DB.error_info($!)
+  DB[:test2].insert(test1_id: 1) rescue DB.error_info($!)
   # => {
   #  :schema=>"public",
   #  :table=>"test2",

data/doc/querying.rdoc

@@ -357,7 +357,9 @@ For ranges, Sequel uses a pair of inequality statements:
   # SELECT * FROM artists WHERE ((id >= 1) AND (id < 5))
 
 Finally, for regexps, Sequel uses an SQL regular expression.  Note that this
-is probably only supported on PostgreSQL and MySQL.
+is only supported by default on PostgreSQL and MySQL.  It can also be supported
+on SQLite when using the sqlite adapter with the :setup_regexp_function
+Database option.
 
   Artist.where(name: /JM$/)
   # SELECT * FROM artists WHERE (name ~ 'JM$')
@@ -498,7 +500,7 @@ filters:
   # SELECT * FROM artists WHERE (id != 5)
   
   Artist.where(id: 5).exclude{name > 'A'}
-  # SELECT * FROM artists WHERE ((id = 5) OR (name <= 'A')
+  # SELECT * FROM artists WHERE ((id = 5) AND (name <= 'A')
 
 So to do a NOT IN with an array:
 
@@ -713,7 +715,7 @@ aggregation:
 
   Album.select_group(:artist_id).select_append{sum(num_tracks).as(tracks)}
   # SELECT artist_id, sum(num_tracks) AS tracks FROM albums GROUP BY artist_id
-
+  
 == Having
 
 The SQL HAVING clause is similar to the WHERE clause, except that

data/doc/release_notes/5.46.0.txt

@@ -0,0 +1,87 @@
+= New Features
+
+* An unused_associations plugin has been added, which allows you to
+  determine which associations and association methods are not used.
+  You can use this to avoid defining the unused associations and
+  association methods, which can save memory.
+
+  This plugin is supported on Ruby 2.5+, and uses method coverage to
+  determine if the plugin's methods are called.  Because Sequel::Model
+  adds association methods to an anonymous module included in the
+  class, directly using the method coverage data to determine which
+  associations are used is challenging.
+
+  This plugin is mostly designed for reporting.  You can have a
+  test suite that runs with method coverage enabled, and use the
+  coverage information to get data on unused associations:
+
+    # Calls Coverage.result
+    cov_data = Sequel::Model.update_associations_coverage
+    unused_associations_data = Sequel::Model.update_unused_associations_data(coverage_data: cov_data)
+    Sequel::Model.unused_associations(unused_associations_data: unused_associations_data)
+    # => [["Class1", "assoc1"], ...]
+
+  unused_associations returns an array of two element arrays, where
+  the first element is the class name and the second element is the
+  association name.  The returned values will be associations where
+  all of the association methods are not used.
+
+  In addition to determining which associations are not used, you can
+  also use this to determine if you are defining association methods
+  that are not used:
+
+    Sequel::Model.unused_association_options(unused_associations_data: unused_associations_data)
+    # => [["Class2", "assoc2", {:read_only=>true}], ...]
+
+  unused_association_options is similar to unused_associations, but
+  returns an array of three element arrays, where the third element
+  is a hash of association options that should be used to avoid
+  defining the unused association methods.  It's common in Sequel to
+  define associations and only use them for reading data and not for
+  modifications, and you can use this to easily see which associations
+  are only used for reading data.
+
+  As the determination of whether associations are used is based on
+  method coverage, this will report as unused any associations that are
+  used but where the association methods are not called.  These cases
+  are rare, but can happen if you have libraries that use the
+  association reflection metadata without calling the association
+  methods, or use the association only in combination with another
+  plugin such as dataset_associations.  You can set the :is_used
+  association option to explicitly mark an association as used, and
+  have this plugin avoid reporting it as unused.
+
+  In addition to just reporting on unused associations, you can also
+  directly use the unused associations metadata to automatically avoid
+  defining unused associations or unused associations methods.  You
+  can set a :file option when loading the plugin:
+
+    Sequel::Model.plugin :unused_associations, file: 'unused_associations.json'
+
+  Then run the method coverage testing.  This will save the unused
+  associations metadata to the file.  Then you can use this metadata
+  automatically by also setting the :modify_associations option:
+
+    Sequel::Model.plugin :unused_associations, file: 'unused_associations.json',
+      modify_associations: true
+
+  With the :modify_associations option, unused associations are
+  skipped instead of being defined, and the options returned by
+  unused_association_options are automatically used.  Note that using
+  the :modify_associations option is risky unless you have complete 
+  coverage and do not have cases where the associations are used
+  without calling methods.
+
+  It is common to have multiple test suites where you need to combine
+  coverage.  The plugin supports this by using a :coverage_file option:
+
+    Sequel::Model.plugin :unused_associations, coverage_file: 'unused_associations_coverage.json'
+
+  In this case, you would run update_associations_coverage after each
+  test suite, and update_unused_associations_data only after all test
+  suites have been run.
+
+* Passing nil as the value of the :setter, :adder, :remover, or
+  :clearer association options will cause the related method to not be
+  defined, instead of using the default value.  This allows you to
+  only define the methods you will actually be using.

data/doc/release_notes/5.47.0.txt

@@ -0,0 +1,59 @@
+= New Features
+
+* Sequel now supports using separate queries for each table for both
+  lazy and eager loading of the following associations:
+
+  * many_to_many
+  * one_through_one
+  * many_through_many # many_through_many plugin
+  * one_through_many # many_through_many plugin
+
+  For many_to_many/one_through_one, you specify the :join_table_db
+  association option, which should be a Sequel::Database instance
+  containing the join table.  It is possible for the current table,
+  join table, and associated table all to be in separate databases:
+
+    JOIN_TABLE_DB = Sequel.connect('...')
+    Album.many_to_many :artists, join_table_db: JOIN_TABLE_DB
+
+  For many_through_many/one_through_many, you can use the :db option
+  in each join table specification.  All join tables can be in
+  separate databases:
+
+    JTDB1 = Sequel.connect('...')
+    JTDB2 = Sequel.connect('...')
+    # Tracks on all albums this artist appears on
+    Artist.many_through_many :album_tracks, [
+        {table: :albums_artists, left: :artist_id, right: :album_id, db: JTDB1},
+        {table: :artists, left: :id, right: :id, db: JTDB2}
+      ],
+      class: :Track, right_primary_key: :album_id
+
+* The :allow_eager_graph association option has been added. Setting
+  this option to false will disallow eager loading via #eager_graph.
+  This is useful if you can eager load the association via #eager,
+  but not with #eager_graph.
+
+* The :allow_filtering_by association option has been added. Setting
+  this option to false will disallow the use of filtering by
+  associations for the association.
+
+* Dataset#returning is now supported on SQLite 3.35.0+. To work around
+  bugs in the SQLite implementation, identifiers used in the RETURNING
+  clause are automatically aliased.  Additionally, prepared statements
+  that use the RETURNING clause on SQLite seem to have issues, so the
+  prepared_statements plugin does not automatically use prepared
+  statements on SQLite for queries that use the RETURNING clause.
+
+* Database#rename_tables has been added on MySQL to support renaming
+  multiple tables in the same query.
+
+= Other Improvements
+
+* The unused_associations plugin now tracks access to the association
+  reflection for associations, so it will no longer show an
+  association as completely unused if something is accessing the
+  association reflection for it.  This eliminates most of the false
+  positives, where the plugin would show an association as unused
+  even though something was using it without calling the association
+  methods.

data/doc/release_notes/5.48.0.txt

@@ -0,0 +1,14 @@
+= New Features
+
+* A Sequel::Database#like_without_collate accessor has been added on
+  Microsoft SQL Server, which avoids using the COLLATE clause for
+  LIKE expressions.  This can speed up query performance significantly.
+
+* A private Sequel::Model::Errors#full_message method has been added
+  to make it easier to support internationalization for Sequel::Model
+  error messages.
+
+= Other Improvements
+
+* The association reflection tracking in the unused_associations
+  plugin now works correctly when combining coverage runs.

data/doc/release_notes/5.49.0.txt

@@ -0,0 +1,59 @@
+= New Features
+
+* Model#validates_no_null_byte has been added to the
+  validation_helpers.  It checks that the value being validated does
+  not contain an ASCII NUL ('\0') byte.  Some databases will return an
+  error if a string contains a NUL byte.
+
+  The auto_validations plugin will now automatically add no_null_byte
+  validations for all string columns in the model's table.  This will
+  change exceptions raised by NUL bytes from database errors to
+  validation failures.
+  
+  If you are using auto_validations and would like to have a table
+  accept NUL bytes in string columns, use the following code inside
+  the model:
+
+    skip_auto_validations(:no_null_byte)
+
+* JSONB subscripts are now supported on PostgreSQL 14+ when using the
+  pg_json_ops extension.  You can use JSONB subscripts to more easily
+  update part of a JSONB column:
+
+    DB[:table].update(Sequel.pg_jsonb_op(:column)['key'] => 'value')
+    UPDATE "table" SET "column"['key'] = 'value'
+
+* hstore subscripts are now supported on PostgreSQL 14+ when using the
+  pg_hstore_ops extension.  You can use hstore subscripts to more
+  easily update part of an hstore column:
+
+    DB[:table].update(Sequel.hstore_op(:column)['key'] => 'value')
+    UPDATE "table" SET "column"['key'] = 'value'
+
+* Sequel now supports table aliases for JOIN USING columns on
+  PostgreSQL 14+.  These allow you to reference the USING columns in
+  the query using a qualified identifier. To use this support, pass an
+  SQL::AliasedExpression as the expression to join on:
+
+    DB[:t1].join(:t2, Sequel.as([:c1, :c2], :alias))
+    # SELECT * FROM "t1" INNER JOIN "t2" USING ("c1", "c2") AS "alias"
+
+* Database#create_trigger on PostgreSQL now supports a :replace option
+  for CREATE OR REPLACE TRIGGER (supported in PostgreSQL 14+).
+
+* SQL::Expression#sequel_ast_transform has been added to support
+  AST transforms of custom expression classes.
+
+= Other Improvements
+
+* Sequel now supports calling PostgreSQL procedures without arguments
+  when using Database#call_procedure.  Previously, attempts to call
+  procuredures without arguments would call the procedure with a
+  single NULL argument.
+
+* Sequel now uses defined?(yield) instead of block_given? internally
+  for better performance on CRuby.  defined?(yield) is faster as it is
+  built into the VM, while block_given? is a regular method and has
+  the overhead of calling a regular method.  Note that defined?(yield)
+  is not implemented correctly on JRuby before 9.0.0.0, so this
+  release of Sequel drops support for JRuby versions before 9.0.0.0.

data/doc/release_notes/5.50.0.txt

@@ -0,0 +1,78 @@
+= New Features
+
+* A pg_multirange extension has been added with support for PostgreSQL
+  14+ multirange types.  Multirange types are similar to an array of
+  ranges, where a value is in the multirange if it is in any of the
+  ranges contained in the multirange. Multiranges are useful when you
+  need to check against multiple ranges that do not overlap.
+
+  You can create multiranges using Sequel.pg_multirange, passing
+  an array of ranges and a multirange type:
+
+    DB.extension :pg_multirange
+    multirange = Sequel.pg_multirange(array_of_date_ranges, :datemultirange)
+
+  Sequel.pg_multirange returns a PGMultiRange, which operates as a
+  delegate to an array of PGRange objects.  Behavior of the object
+  is similar to an array, except that cover? is supported, which will
+  test if any of the included ranges covers the argument:
+
+    multirange.cover?(Date.today)
+
+  Like the pg_range extension, this also supports registering custom
+  multirange types, and using multirange types as bound variables.
+
+  The pg_range_ops extension now supports both ranges and multiranges,
+  with a few new methods added to Postgres::RangeOp for converting
+  between them:
+
+  * range_merge
+  * multirange
+  * and unnest
+
+* An sql_log_normalizer extension has been added for normalizing
+  logged SQL, replacing numbers and strings inside the SQL string
+  with question marks.  This is useful for analytics and sensitive
+  data.
+
+    DB[:table].first(a: 1, b: 'something')
+    # Without sql_log_normalizer extension, logged SQL is:
+    # SELECT * FROM "table" WHERE (("a" = 1) AND ("b" = 'something')) LIMIT 1
+
+    DB.extension :sql_log_normalizer
+    DB[:table].first(a: 1, b: 'something')
+    # With sql_log_normalizer_extension, logged SQL is:
+    # SELECT * FROM "table" WHERE (("a" = ?) AND ("b" = ?)) LIMIT ?
+
+  This extension scans the logged SQL for numbers and strings,
+  attempting to support the database's rules for string quoting.  This
+  means it should work with SQL that Sequel didn't itself create.
+  However, there are corner cases that the extension doesn't handle,
+  such as the use of apostrophes inside quoted identifiers, and
+  potentially other cases of database specific SQL where the normal
+  string quoting rules are changed, such as the use of escape strings
+  on PostgreSQL (E'escape string').
+
+* A :before_preconnect Database option has been added.  This is useful
+  for configuring extensions added via :preconnect_extensions before
+  the connection takes place.
+
+= Other Improvements
+
+* Dataset#columns! now uses a LIMIT 0 query instead of a LIMIT 1 query
+  by default. This can improve performance in cases where the row
+  returned would be large.  Some databases do not support a LIMIT 0
+  query, and some adapters that ship with Sequel have been updated to
+  continue using LIMIT 1.  Custom adapters should be updated to use
+  LIMIT 1 if the database does not support LIMIT 0.
+
+* The lazy_attributes plugin no longer modifies the database schema.
+  Previously, it could modify the database schema indirectly,
+  resulting in the loss of typecasting for models that were not
+  based on a single table or view, such as usage with the
+  class_table_inheritance plugin.
+
+* Model#freeze in the composition, serialization, and
+  serialization_modification_detection plugins now returns self. In
+  addition to being more correct, this fixes usage of these plugins
+  with the static_cache plugin.

data/doc/release_notes/5.51.0.txt

@@ -0,0 +1,47 @@
+= New Features
+
+* On PostgreSQL 14+, Dataset#with_recursive now supports :search and
+  :cycle options for result ordering and cycle detection.  These use
+  the SEARCH and CYCLE clauses added in PostgreSQL 14:
+
+    DB[:t].with_recursive(:t,
+      DB[:i1].where(parent_id: nil),
+      DB[:i1].join(:t, id: :parent_id).select_all(:i1),
+      search: {by: :id, type: :breadth},
+      cycle: {columns: :id, cycle_value: 1, noncycle_value: 2})
+
+    # WITH RECURSIVE t AS (
+    #     SELECT * FROM i1 WHERE (parent_id IS NULL)
+    #     UNION ALL
+    #     (SELECT i1.* FROM i1 INNER JOIN t ON (t.id = i1.parent_id))
+    #   )
+    #   SEARCH BREADTH FIRST BY id SET ordercol
+    #   CYCLE id SET is_cycle TO 1 DEFAULT 2 USING path
+
+* On MySQL, column schema hashes now contain an :extra entry, which
+  contains the Extra string returned in MySQL's DESCRIBE results
+  for the column.
+
+= Other Improvements
+
+* When eager loading via the tactical_eager_loading plugin, objects
+  that already have an association loaded will not have it reloaded
+  unless the :eager_reload option is given.
+
+* When cloning an association and using a different :class option
+  than the cloned association, the :class option given when cloning
+  will now take precedence over the :class option for the cloned
+  association.
+
+* When using the mock postgres adapter, the adapter defaults to
+  supporting PostgreSQL 14 (previously, it defaulted to supporting
+  PostgreSQL 9.5).
+
+* Sequel now avoids a method redefined warning in the lazy attributes
+  plugin in verbose warnings mode.
+
+= Other
+
+* Sequel's primary discussion forum is now GitHub Discussions. The
+  sequel-talk Google Group is still available for users who would
+  prefer to use that instead.

data/doc/release_notes/5.52.0.txt

@@ -0,0 +1,87 @@
+= New Features
+
+* When the sql_comments Database extension is used,
+  Database#with_comments is now added, which can be used for including
+  comments for all queries executed inside a given block.  This can
+  be useful if you want to analyze database query logs, and want to
+  group all related queries:
+
+     DB.with_comments(model: Album, action: :all) do
+       DB[:albums].all
+       # SELECT * FROM albums -- model:Album,action:all
+    end
+
+* An sql_comments plugin has been added, which will automatically
+  add SQL comments for all queries generated by model class, instance
+  and dataset methods:
+
+    Album.plugin :sql_comments
+
+    album = Album[1]
+    # SELECT * FROM albums WHERE (id = 1) LIMIT 1
+    # -- model:Album,method_type:class,method:[]
+
+    album.update(:name=>'A')
+    # UPDATE albums SET name = 'baz' WHERE (id = 1)
+    # -- model:Album,method_type:instance,method:update
+
+    Album.where(id: 1).delete
+    # DELETE FROM albums WHERE (id = 1)
+    # -- model:Album,method_type:dataset,method:delete
+
+  This plugin requires you have loaded the sql_comments Database
+  extension into the related Database before use.
+
+* A date_parse_input_handler extension has been added to support
+  custom handling of input to date parsing methods.  Among other
+  things, you can use this to limit the length of strings that
+  will be parsed, which can prevent ArgumentErrors in newer Ruby
+  versions:
+
+    Sequel.extension :date_parse_input_handler
+    Sequel.date_parse_input_handler do |string|
+      string.b[0, 128]
+    end
+
+= Other Improvements
+
+* On Ruby 3.1, the core_refinements extension now avoids the
+  deprecated Refinement#include, switching to
+  Refinement#import_methods.
+
+* On Ruby 3.1, the subclasses plugin will use Ruby's native support
+  for Class#subclasses.
+
+* The subclasses plugin has renamed descendents to descendants and
+  freeze_descendents to freeze_descendants.  The previous method
+  names are still available as aliases.
+
+* The :ruby_default schema entry for datetime/timestamp columns now
+  respects Sequel.datetime_class.  Previously, the value for the
+  :ruby_default schema entry would always be a DateTime value for
+  such columns.
+
+* The pg_interval extension now works with ActiveSupport 7.0.
+
+* The shared postgres adapter now respects
+  Database#default_string_column_size for setting the size of string
+  columns that don't use text as the database type.
+
+* Database#supports_check_constraints? now returns true on MySQL
+  8.0.19+. This fixes drop_constraint in certain cases when combining
+  the constraint dropping with other changes in the same alter_table
+  block.
+
+* The mysql adapter now supports the ruby-mysql 3 API (ruby-mysql
+  is a pure-ruby MySQL driver).
+
+* The mysql adapter no longer uses the connection's server_version
+  method if it is defined, as the method does not return the
+  correct value when using the ruby-mysql driver with MariaDB.
+
+* Comments added by the sql_comments extension no longer modify
+  cached SQL for a dataset.
+
+= Other
+
+* This is Sequel's 250th release!

data/doc/release_notes/5.53.0.txt

@@ -0,0 +1,23 @@
+= Improvements
+
+* The jdbc/h2 subadapter now supports H2 version 2.0.  It continues to
+  support H2 versions 1.3 and 1.4.
+
+* The mysql2 adapter's prepared statement support now reuses existing
+  native prepared statements, instead of only binding variables on
+  newly prepared statements.  This was the intended behavior
+  previously, and should result in increased performance in cases
+  where preparing a query takes significant time.
+
+* The subclasses plugin now ignores an existing Class#subclasses
+  method if it is defined in Ruby.  This fixes cases where usage of
+  ActiveSupport would break the subclasses plugin.
+
+* Database#call_sproc in the jdbc adapter will now always close the
+  prepared call it creates.  Before, if there was an exception raised
+  when setting the arguments for the prepared call, the prepared call
+  would not be closed.
+
+* A more appropriate error is now issued if you try to use the
+  column_encryption plugin to encrypt a column without setting up an
+  encryption key.