sequel 5.58.0 → 5.78.0

data/doc/association_basics.rdoc

@@ -320,11 +320,11 @@ Associations are cached after being retrieved:
   @album.artists # Cached - No Database Query
   
 You can choose to ignore the cached versions and do a database query to
-retrieve results by passing a :reload=>true option to the association method:
+retrieve results by passing a <tt>reload: true</tt> option to the association method:
 
   @album.artists # Not cached - Database Query
   @album.artists # Cached - No Database Query
-  @album.artists(:reload=>true) # Ignore cache - Database Query
+  @album.artists(reload: true) # Ignore cache - Database Query
 
 If you reload/refresh the object, it will automatically clear the
 associations cache for the object:
@@ -342,6 +342,12 @@ instance method:
   @album.artists # [<Artist ...>, ...]
   @album.associations[:artists] # [<Artist ...>, ...]
 
+=== Code Reloading
+
+When declaring associations, Sequel caches association metadata in the association reflection. If you're doing any code reloading that doesn't involve restarting the related process, you should disable caching of the association reflection, to avoid stale model classes still being referenced after reloading:
+
+  Sequel::Model.cache_associations = false
+
 == Dataset Method
 
 In addition to the above methods, associations also add an instance method
@@ -532,14 +538,14 @@ Which could be created using the following Sequel code:
   DB.create_table(:artists) do
     # Primary key must be set explicitly
     primary_key :id
-    String :name, :null=>false, :unique=>true
+    String :name, null: false, unique: true
   end
   DB.create_table(:albums) do
     primary_key :id
     # Table that foreign key references needs to be set explicitly
     # for a database foreign key reference to be created.
-    foreign_key :artist_id, :artists, :null=>false
-    String :name, :null=>false, :unique=>true
+    foreign_key :artist_id, :artists, null: false
+    String :name, null: false, unique: true
   end
 
 If you already had a schema such as:
@@ -552,7 +558,7 @@ If you already had a schema such as:
 Then you just need to add the column:
 
   DB.alter_table(:albums) do
-    add_foreign_key :artist_id, :artists, :null=>false
+    add_foreign_key :artist_id, :artists, null: false
   end
 
 === many_to_many
@@ -588,11 +594,11 @@ wanted to add an albums_artists join table to create the following schema:
 
 You could use the following Sequel code:
 
-  DB.create_join_table(:album_id=>:albums, :artist_id=>:artists)
+  DB.create_join_table(album_id: :albums, artist_id: :artists)
   # or
   DB.create_table(:albums_artists) do
-    foreign_key :album_id, :albums, :null=>false
-    foreign_key :artist_id, :artists, :null=>false
+    foreign_key :album_id, :albums, null: false
+    foreign_key :artist_id, :artists, null: false
     primary_key [:album_id, :artist_id]
     index [:artist_id, :album_id]
   end
@@ -713,7 +719,7 @@ saving the passed in (or newly created) object.  However, to avoid
 silent failures of these methods, they explicitly raise exceptions
 even when raise_on_save_failure is false for the associated model.
 You can disable this behavior (i.e. return nil instead of raising
-exceptions on a save failure) by setting the <tt>:raise_on_save_failure=>false</tt>
+exceptions on a save failure) by setting the <tt>raise_on_save_failure: false</tt>
 option for the association.
 
 === remove_<i>association</i>(object_to_disassociate) (e.g. remove_album) [+one_to_many+ and +many_to_many+]
@@ -858,14 +864,14 @@ You can set this to +nil+ to not create a remove_all_<i>association</i> method.
 
 === :no_dataset_method
 
-Setting this to true will not result in the <i>association</i>_dataset method
+Setting this to true will result in the <i>association</i>_dataset method
 not being defined. This can save memory if you only use the <i>association</i>
 method and do not call the <i>association</i>_dataset method directly or
 indirectly.
 
 === :no_association_method
 
-Setting this to true will not result in the <i>association</i> method
+Setting this to true will result in the <i>association</i> method
 not being defined. This can save memory if you only use the
 <i>association</i>_dataset method and do not call the <i>association</i> method
 directly or indirectly.
@@ -981,7 +987,7 @@ If you do not use a hash or array of two element arrays, you should use the
 :graph_conditions, :graph_only_conditions, or :graph_block option or you will not
 be able to use eager_graph or association_join with the association.
 
-  Artist.one_to_many :good_albums, class: :Album, conditions: {:good=>true}
+  Artist.one_to_many :good_albums, class: :Album, conditions: {good: true}
   @artist.good_albums
   # SELECT * FROM albums WHERE ((artist_id = 1) AND (good IS TRUE))
 
@@ -1162,7 +1168,7 @@ join of the join table and the associated table, whereas this option just
 applies to the join table.  It can be used to make sure that filters are used
 when deleting.
 
-  Artist.many_to_many :lead_guitar_albums, class: :Album, :join_table_block=>(lambda do |ds|
+  Artist.many_to_many :lead_guitar_albums, class: :Album, join_table_block: (lambda do |ds|
     ds.where(instrument_id: 5)
   end)
 
@@ -1177,7 +1183,7 @@ access to the join table.
 For example, if the Album class uses a different Sequel::Database than the Artist
 class, and the join table is in the database that the Artist class uses:
 
-  Artist.many_to_many :lead_guitar_albums, class: :Album, :join_table_db=>Artist.db
+  Artist.many_to_many :lead_guitar_albums, class: :Album, join_table_db: Artist.db
 
 This option also affects the add/remove/remove_all methods, by changing
 which database is used for inserts/deletes from the join table (add/remove/remove_all
@@ -1470,7 +1476,7 @@ at least the following keys:
 Example:
 
   Artist.one_to_many :self_title_albums, class: :Album,
-   :eager_grapher=>(lambda do |eo|
+   eager_grapher: (lambda do |eo|
     eo[:self].graph(:albums, {artist_id: :id, name: :name},
       table_alias: eo[:table_alias], implicit_qualifier: eo[:implicit_qualifier])
   end)
@@ -1492,6 +1498,36 @@ as the qualifiers may not match the aliases automatically used by eager_graph.
 This should contain unqualified identifiers, and eager_graph will automatically
 qualify them with the appropriate alias.
 
+==== :graph_use_association_block
+
+Setting this to true makes eager_graph apply the association block to the
+associated dataset before graphing the associated dataset into the receiver.
+In most cases when this option is used and the association has a block, the
+dataset returned by eager_graph will contain a JOIN to a subquery.
+
+By default (when this option is not used), the association block will be ignored
+when using eager_graph:
+
+  Artist.one_to_many :tracks do |ds|
+    ds.where(foo: 3)
+  end
+  Artist.eager_graph(:tracks)
+  # SELECT albums.id, tracks.id AS tracks_id, tracks.album_id
+  # FROM albums
+  # LEFT OUTER JOIN tracks
+  # ON (tracks.album_id = albums.id)
+
+When this option is used, the block will be respected:
+
+  Artist.one_to_many :tracks, graph_use_association_block: true do |ds|
+    ds.where(foo: 3)
+  end
+  Artist.eager_graph(:tracks)
+  # SELECT albums.id, tracks.id AS tracks_id, tracks.album_id
+  # FROM albums
+  # LEFT OUTER JOIN (SELECT * FROM tracks WHERE (foo = 3)) AS tracks
+  # ON (tracks.album_id = albums.id)
+
 ==== :graph_join_table_conditions [+many_to_many+, +one_through_one+]
 
 The additional conditions to use on the SQL join for the join table when
@@ -1727,7 +1763,7 @@ support joins.
 If set to false, you cannot use the association when filtering.
 
   Artist.one_to_many :albums, allow_filtering_by: false
-  Artist.where(:albums=>Album.where(:name=>'A')).all # Raises Sequel::Error
+  Artist.where(albums: Album.where(name: 'A')).all # Raises Sequel::Error
 
 This is useful if such filtering cannot work, such as when a subquery cannot
 be used because the necessary tables are not in the same database.

data/doc/cheat_sheet.rdoc

@@ -54,8 +54,8 @@ Without a filename argument, the sqlite adapter will setup a new sqlite database
 == Update/Delete rows
 
   dataset.exclude(:active).delete
-  dataset.where{price < 100}.update(:active => true)
-  dataset.where(:active).update(:price => Sequel[:price] * 0.90)
+  dataset.where{price < 100}.update(active: true)
+  dataset.where(:active).update(price: Sequel[:price] * 0.90)
 
 = Merge rows
 
@@ -174,7 +174,7 @@ Without a filename argument, the sqlite adapter will setup a new sqlite database
     String :name, unique: true, null: false
     TrueClass :active, default: true
     foreign_key :category_id, :categories
-    DateTime :created_at, default: Sequel::CURRENT_TIMESTAMP, :index=>true
+    DateTime :created_at, default: Sequel::CURRENT_TIMESTAMP, index: true
     
     index [:category_id, :active]
   end

data/doc/mass_assignment.rdoc

@@ -48,7 +48,7 @@ If you want to change mass assignment so it ignores attempts to access restricte
 Since mass assignment by default allows modification of all column values except for primary key columns, it can be a security risk in some cases.
 If you are dealing with untrusted input, you are generally going to want to restrict what should be updated.
 
-Sequel has <tt>Model#set_fields</tt> and <tt>Model#update_fields</tt> methods, which are designed to be used with untrused input.
+Sequel has <tt>Model#set_fields</tt> and <tt>Model#update_fields</tt> methods, which are designed to be used with untrusted input.
 These methods take two arguments, the untrusted hash as the first argument, and a trusted array of field names as the second argument:
 
   post.set_fields({title: 'T', body: 'B'}, [:title, :body])

data/doc/migration.rdoc

@@ -86,9 +86,24 @@ the following methods:
   * +add_full_text_index+
   * +add_spatial_index+
   * +rename_column+
+  * +set_column_allow_null+
 
 If you use any other methods, you should create your own +down+ block.
 
+To revert a migration created with +change+, you can copy the migration to a new file, and
+replace +change+ with +revert+. For example, if you no longer need the artists table, you
+can use the following migration.  This will drop the artists table when migrating up, and
+recreate it when migrating down:
+
+  Sequel.migration do
+    revert do
+      create_table(:artists) do
+        primary_key :id
+        String :name, null: false
+      end
+    end
+  end
+
 In normal usage, when Sequel's migrator runs, it runs the +up+ blocks for all
 migrations that have not yet been applied.  However, you can use the <tt>-M</tt>
 switch to specify the version to which to migrate, and if it is lower than the

data/doc/model_hooks.rdoc

@@ -199,7 +199,7 @@ While it's not enforced anywhere, it's a good idea to make +super+ the last expr
 
     def after_save
       super
-      AuditLog.create(:log=>"Album #{name} created")
+      AuditLog.create(log: "Album #{name} created")
     end
   end
 

data/doc/object_model.rdoc

@@ -36,7 +36,7 @@ schema modification,
 and transactions:
 
   DB.transaction do
-    DB[:table].insert(:column=>value)
+    DB[:table].insert(column: value)
   end
 
 Sequel::Database#literal can be used to take any object that Sequel handles
@@ -468,7 +468,7 @@ objects:
   Sequel.lit(['', ' = '], :a, 1)
 
   '? = ?'.lit(:a, 1) # core_extensions extension
-  ':b = :v'.lit(:b=>:a, :v=>1) # core_extensions extension
+  ':b = :v'.lit(b: :a, v: 1) # core_extensions extension
 
 === Sequel::SQL::OrderedExpression
 
@@ -482,20 +482,20 @@ it ascending or descending:
 Additionally, they take an options hash, which can be used to specify how nulls
 can be sorted:
 
-  Sequel::SQL::OrderedExpression.new(:a, true, :nulls=>:first) # "a" DESC NULLS FIRST
-  Sequel::SQL::OrderedExpression.new(:a, false, :nulls=>:last) # "a" ASC NULLS LAST
+  Sequel::SQL::OrderedExpression.new(:a, true, nulls: :first) # "a" DESC NULLS FIRST
+  Sequel::SQL::OrderedExpression.new(:a, false, nulls: :last) # "a" ASC NULLS LAST
 
 The following shortcuts exist for creating Sequel::SQL::OrderedExpression objects:
 
   Sequel.asc(:a)
   Sequel.desc(:a)
-  Sequel.asc(:a, :nulls=>:first)
-  Sequel.desc(:a, :nulls=>:last)
+  Sequel.asc(:a, nulls: :first)
+  Sequel.desc(:a, nulls: :last)
 
   :a.asc # core_extensions extension
   :a.desc # core_extensions extension
-  :a.asc(:nulls=>:first) # core_extensions extension
-  :a.desc(:nulls=>:last) # core_extensions extension
+  :a.asc(nulls: :first) # core_extensions extension
+  :a.desc(nulls: :last) # core_extensions extension
 
 === Sequel::SQL::Subscript
 

data/doc/opening_databases.rdoc

@@ -268,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
@@ -279,7 +279,7 @@ 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. 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
@@ -290,13 +290,13 @@ mysql, such as the jdbc/mysql adapter).
 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 
 
@@ -312,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:
 
@@ -346,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.
 
@@ -389,8 +388,10 @@ 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.  Note that this creates a new
-                          Regexp object per call to the function, so it is not an efficient implementation.
+                          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
@@ -424,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
 
@@ -561,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

@@ -715,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.59.0.txt

@@ -0,0 +1,73 @@
+= New Features
+
+* A require_valid_schema plugin has been added, for checking that
+  model classes have schema parsed as expected.  By default, model
+  classes are not required to have valid schema, because it is
+  allowed to have model classes based on arbitrary datasets (such
+  as those using joins or set-returning functions), and it is not
+  possible to determine the schema for arbitary datasets.
+
+  Sequel swallows non-connection errors when trying to parse schema
+  for a model's dataset, but if schema parsing fails when you would
+  expect it to succeed, it results in a model where typecasting does
+  not work as expected.
+
+  The require_valid_schema plugin will raise an error when setting
+  the dataset for a model if schema parsing fails and the dataset
+  uses a simple table where you would expect schema parsing to
+  succeed.  You can also provide an argument of :warn when loading
+  the plugin, to warn instead of raising an error.
+
+  This plugin may not work correctly in all cases for all adapters,
+  especially external adapters. Adapters are not required to support
+  schema parsing.  Even if supported, adapters may not support
+  parsing schema for qualified tables, or parsing schema for views.
+  You should consider this plugin as a possible safety net.  Users
+  are encouraged to try using it and report any unexpected breakage,
+  as that may help improve schema parsing in adapters that Sequel
+  ships.
+
+* is_json and is_not_json methods have been added to the pg_json_ops
+  extension, for the IS [NOT] JSON operator supported in PostgreSQL
+  15+.
+
+* Index creation methods on PostgreSQL 15+ now support a
+  :nulls_distinct option, for NULLS [NOT] DISTINCT.  This allows you
+  to create unique indexes where NULL values are not considered
+  distinct.
+
+* View creation methods on PostgreSQL 15+ now support a
+  :security_invoker option to create a view where access is
+  determined by the permissions of the role that is accessing the
+  view, instead of the role that created the view.
+
+= Other Improvements
+
+* The :allow_eager association option is now set to false by default
+  for associations explicitly marked as :instance_specific, if the
+  :eager_loader association is not given.
+  
+* The postgres adapter now supports the sequel-postgres-pr driver.
+  The sequel-postgres-pr driver is a slimmed down fork of the
+  postgres-pr driver designed specifically for use by Sequel.
+
+* Model code that explicitly does not swallow connection errors
+  will also now not swallow disconnect errors. This can fix issues
+  where model classes are being loaded at runtime, and the query to
+  get the columns/schema for the model uses a connection that has
+  been disconnected.
+
+* Model classes created from aliased expressions and literal
+  strings no longer use the simple_table optimization, as there
+  are cases where doing so is not safe.
+
+= Backwards Compatibility
+
+* The change to not swallow disconnect errors when not swallowing
+  connection errors can result in exceptions being raised which
+  weren't raised previously.  In most cases, this will alert you
+  to issues in your application that should be fixed, but it
+  potentially it can result in regressions if you were OK with
+  the errors being swallowed.  If this does result in regressions
+  in your application, please file an issue and we can probably
+  add a setting controlling this feature.

data/doc/release_notes/5.60.0.txt

@@ -0,0 +1,22 @@
+= New Features
+
+* The date_arithmetic extension now supports arbitrary expressions
+  as interval values on PostgreSQL 9.4+.  Previously, only integers
+  were supported for the interval values.
+
+= Other Improvements
+
+* Most Kernel#respond_to? calls have been converted to equivalent
+  defined? calls for better performance.  defined? is a keyword
+  and is about 50% faster for the same behavior.
+
+* The is_distinct_from extension now supports the IS DISTINCT FROM
+  syntax natively on SQLite 3.39+, instead of emulating it.
+
+* HAVING without GROUP BY is now supported on SQLite 3.39+.
+
+* Coverage testing has been significantly expanded.  Previously,
+  the core, model, plugin, and extension code had 100% line/branch
+  coverage.  100% line/branch coverage has been added for the
+  core extensions, bin/sequel, and the postgres adapter with the
+  pg driver.

data/doc/release_notes/5.61.0.txt

@@ -0,0 +1,43 @@
+= Improvements
+
+* When typecasting strings to other types, Sequel::Database will now
+  by default not typecast strings that are much longer than expected
+  for the underlying type. Depending on the underlying type, there
+  is a limit of either 100 or 1000 bytes on the input string.  This
+  avoids potential performance issues when trying to convert
+  arbitrary sized user input to specific types.
+
+* The respond_to? to defined? change made in 5.60.0 was reverted in
+  5.60.1 as it broke cases on Ruby < 3 where the object had an unused
+  refinement that added the method.
+
+* When typecasting strings to integer, strings such as -0xa are now
+  treated as negative hexidecimal strings, similar to how 0xa is
+  treated as a positive hexidecimal string.
+
+* Database#foreign_key_list now returns results for partitioned
+  tables on PostgreSQL 11+.
+
+* Timestamps before the date of calendar reform are now handled
+  correctly by the pg_extended_date_support extension when using
+  Ruby 3.2 preview 2+.
+
+= Backwards Compatibility
+
+* The change to not typecast strings that are too long can break
+  backwards compatibility for applications that expect typecasting
+  for input beyond Sequel's limits.  You can disable the string
+  bytesize checking by setting:
+
+    DB.check_string_typecast_bytesize = false
+
+  or by passing the check_string_typecast_bytesize: false option when
+  creating the Database instance.
+
+* Code to workaround a bug in JRuby 9.2.0.0 has been removed from the
+  pg_extended_date_support extension.  Users of the extension should
+  upgrade to a newer JRuby version.
+
+* The is_json and is_not_json methods have been removed from the
+  pg_json_ops extension, as the underlying support was removed in
+  PostgreSQL 15 beta 4.