sequel 5.60.1 → 5.81.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/code_order.rdoc

@@ -91,9 +91,11 @@ unsafe runtime modification of the configuration:
   model_classes.each(&:freeze)
   DB.freeze
 
-The `subclasses` plugin can be used to keep track of all model classes
-that have been setup in your application. Finalizing their associations
-and freezing them can easily be achieved through the plugin:
+`model_classes` is not a Sequel method, it indicates an array of model
+classes you defined. Instead of listing them manually, the `subclasses`
+plugin can be used to keep track of all model classes that have been
+setup in your application. Finalizing their associations and freezing
+them can easily be achieved through the plugin:
 
   # Register the plugin before setting up the models
   Sequel::Model.plugin :subclasses

data/doc/dataset_basics.rdoc

@@ -65,7 +65,7 @@ Most Dataset methods that users will use can be broken down into two types:
 
 Most dataset methods fall into this category, which can be further broken down by the clause they affect:
 
-SELECT:: select, select_all, select_append, select_group, select_more
+SELECT:: select, select_all, select_append, select_group, select_more, select_prepend
 FROM:: from, from_self
 JOIN:: join, left_join, right_join, full_join, natural_join, natural_left_join, natural_right_join, natural_full_join, cross_join, inner_join, left_outer_join, right_outer_join, full_outer_join, join_table
 WHERE:: where, filter, exclude, or, grep, invert, unfiltered

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 
 
@@ -345,7 +345,9 @@ 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>).
+:unlogged_tables_default :: Set to true to use UNLOGGED by default for created tables, for potentially better performance
+                            when data integrity is not important.
 :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.
 
@@ -388,8 +390,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
@@ -423,3 +427,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

@@ -624,11 +624,16 @@ Like +order+, +select+ replaces the existing selected columns:
   Artist.select(:id).select(:name)
   # SELECT name FROM artists
 
-To add to the existing selected columns, use +select_append+:
+To append to the existing selected columns, use +select_append+:
 
   Artist.select(:id).select_append(:name)
   # SELECT id, name FROM artists
 
+To prepend to the existing selected columns, use +select_prepend+:
+
+  Artist.select(:id).select_prepend(:name)
+  # SELECT name, id FROM artists
+
 To remove specifically selected columns, and default back to all
 columns, use +select_all+:
 
@@ -715,7 +720,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.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.

data/doc/release_notes/5.62.0.txt

@@ -0,0 +1,132 @@
+= New Features
+
+* The pg_auto_parameterize extension for automatically using bound
+  variables when using postgres adapter with the pg driver has been
+  added back to Sequel.  This extension was originally added in Sequel
+  3.34.0, but was removed in 4.0.0 due to the many corner cases it
+  had.  Almost all of the corner cases have now been fixed, and
+  the extension is now recommended for production use.  Compared
+  to the original version in Sequel 3, the reintroduced version
+  of the extension includes the following changes:
+
+  * Handles integers used in LIMIT/ORDER
+  * Respects explicit CASTs
+  * Tries to convert column IN (int, ...) into column = ANY($) with an
+    array parameter
+  * Uses the same parameter for the same object used more than once in
+    a query
+  * Uses parameters when inserting multiple rows via Dataset#import
+  * Supports automatically parameterizing all of the
+    PostgreSQL-specific types that Sequel ships support for in pg_*
+    extensions (though some values of those types may not support
+    automatic parameterization).
+  * Supports skipping auto parameterization for specific values.
+
+  Automatic parameterization is generally slower than Sequel's default
+  behavior, since some optimizations Sequel uses by default do not
+  currently support automatic parameterization.
+
+  Applications may need changes to work correctly with the
+  pg_auto_parameterize extension, such as the addition of explicit
+  casts.  Please read the extension documentation for more details.
+
+* Integer column schema entries now include :min_value and :max_value
+  entries on most databases, indicating the minimum and maximum values
+  supported for the column.
+
+  The validation_helpers plugin now has validates_max_value and
+  validates_min_value for testing the column value is not greater
+  than the given maximum value and not less than the given minimum
+  value, respectively.
+
+  The auto_validations plugin now automatically uses the :min_value
+  and :max_value column schema entries with the new validation_helpers
+  methods to validate that the column values for integer columns are
+  in the allowed range.
+
+* A primary_key_lookup_check_values plugin has been added for
+  automatically typecasting and checking the primary key values are
+  in the allowed range (given by :min_value and :max_value column
+  schema entries) during lookup. If typecasting fails or the value
+  is outside the allowed range, the primary key lookup will return
+  nil without issuing a query (or will raise a NoMatchingRow error
+  if using with_pk!).
+
+  Note that this can change behavior in some cases if you are
+  passing filter conditions during lookup instead of passing primary
+  key values. The plugin tries to support most common filter
+  conditions, but there are still cases that will break.
+
+* Sequel now supports shard-specific :after_connect and :connect_sqls
+  Database options, allowing you to customize behavior for specific
+  shards:
+
+    DB = Sequel.connect('url', servers: {
+        :shard1 => {host: '...', after_connect: proc{|conn|}},
+        :shard2 => {host: '...', connect_sqls: ['...']},
+      })
+
+  Note that these shard-specific options will not be respected if you
+  are calling after_connect= or connect_sqls= on the Database's
+  connection pool.
+
+= Other Improvements
+
+* A Sequel::Postgres::IntegerOutsideBigintRange exception will now be
+  raised if trying to literalize an integer outside PostgreSQL bigint
+  range, to avoid PostgreSQL treating the integer as a numeric type
+  and not respecting indexes on the related column.
+
+  A pg_extended_integer_support extension has been added for
+  customizing the behavior when literalizing an integer outside
+  PostgreSQL bigint range, either quoting it or getting the
+  historical behavior of using it directly in the query.
+
+* Dataset#import and #multi_insert no longer use transactions when
+  they only run a single query.
+
+* Fractional seconds in timestamps are now respected in the
+  named_timezones extension.
+
+* Using hstore[] types as bound variables now works on PostgreSQL.
+
+* Using BC dates and timestamps in bound variables now works on
+  PostgreSQL.
+
+* A corner case has been fixed in eager loading where the window
+  function eager limit strategy would be used without removing the
+  row_number entries from the result.
+
+* The shared postgres adapter now caches reflection datasets, speeding
+  up Database#indexes and similar methods.
+
+* The mock postgres adapter now assumes PostgreSQL 15 instead of
+  PostgreSQL 14 by default.
+
+= Backwards Compatibility
+
+* If you are using Ruby integers outside PostgreSQL bigint range when
+  dealing with PostgreSQL numeric column values, this version may
+  not be compatible.  It is recommended you explicitly convert the
+  Ruby integers to BigDecimal objects if you are using them for
+  numeric column values.  You can also use the
+  pg_extended_integer_support extension introduced in this version.
+
+= Workaround for Older Versions
+
+* If you cannot upgrade to Sequel 5.62.0, but still want to avoid the
+  problems that come from using literal large integers on PostgreSQL,
+  you can use the following code, where DB is your Sequel::Database
+  object:
+
+    DB.extend_datasets do
+      def literal_integer(v)
+        if v > 9223372036854775807 || v < -9223372036854775808
+          raise Sequel::InvalidValue, "PostgreSQL int too large: #{v}"
+        end
+        super
+      end
+    end
+
+  This workaround should work all the way back to Sequel 3.29.0,
+  released in November 2011.