sequel 5.45.0 → 5.77.0

data/doc/release_notes/5.69.0.txt

@@ -0,0 +1,26 @@
+= New Features
+
+* An adapter has been added for the trilogy MySQL driver. One large
+  advantage over mysql2 is that trilogy does not require any MySQL
+  client libraries installed on the machine. The trilogy adapter
+  has basically the same issues/skipped specs as the mysql2 adapter,
+  but it also does not support an application_timezone different
+  than the database_timezone.
+
+* Model dataset modules now have a model accessor, allowing for
+  code such as:
+
+    class Foo < Sequel::Model
+      dataset_module do
+        where :kept, Sequel[model.table_name][:discarded_at] => nil
+      end
+    end
+
+= Improvements
+
+* The mysql adapter now works with ruby-mysql 4 (the pure-ruby
+  MySQL driver).  Note that multi-results support does not work
+  with ruby-mysql 4 (it doesn't work with mysql2, trilogy, or
+  other Sequel adapters in general).
+
+* Warnings for unsupported flags are now avoided on ruby-mysql 3.

data/doc/release_notes/5.70.0.txt

@@ -0,0 +1,35 @@
+= New Features
+
+* A sharded_timed_queue connection pool has been added. This offers
+  most of the same features as the sharded_threaded connection pool,
+  but uses the new Queue#pop :timeout features added in Ruby 3.2 to
+  allow for a simpler and possibly faster and more robust
+  implementation.
+
+* If a :pool_class option is not specified when creating a Database,
+  Sequel will now look at the SEQUEL_DEFAULT_CONNECTION_POOL
+  environment variable to determine the connection pool class to use.
+  This allows you to set SEQUEL_DEFAULT_CONNECTION_POOL=timed_queue
+  on Ruby 3.2 to test with the timed_queue connection pool without
+  making any code changes.  If the :servers Database option is given,
+  Sequel will automatically use the sharded version of the connection
+  pool specified by SEQUEL_DEFAULT_CONNECTION_POOL.
+
+= Other Improvements
+
+* The connection_validator, connection_expiration, and
+  async_thread_pool extensions now work with the timed_queue and
+  sharded_timed_queue connection pools.
+
+* The sharded_threaded connection pool now disconnects connections
+  for all specified servers instead of just the last specified server
+  when using remove_server.
+
+* The static_cache plugin now recognizes when the forbid_lazy_load
+  plugin is already loaded, and does not return instances that
+  forbid lazy load for methods that return a single object, such as
+  Database.{[],cache_get_pk,first}.
+
+* Sequel now displays an informative error message if attempting to
+  load the connection_validator or connection_expiration extensions
+  when using the single threaded connection pool.

data/doc/release_notes/5.71.0.txt

@@ -0,0 +1,21 @@
+= New Features
+
+* A pg_xmin_optimistic_locking plugin has been added.  This plugin
+  uses PostgreSQL's xmin system column to implement optimistic
+  locking.  The xmin system column is automatically updated whenever
+  the database row is updated.  You can load this plugin into a
+  base model and have all models that subclass from it use optimistic
+  locking, without needing any user-defined lock columns.
+
+= Other Improvements
+
+* set_column_allow_null is now a reversible migration method inside
+  alter_table blocks.
+
+* The use of ILIKE no longer forces the ESCAPE clause on PostgreSQL,
+  which allows the use of ILIKE ANY and other constructions.  There
+  is no need to use the ESCAPE clause with ILIKE, because the value
+  Sequel uses is PostgreSQL's default.
+
+* The xid PostgreSQL type is now recognized as an integer type in the
+  jdbc/postgresql adapter.

data/doc/release_notes/5.72.0.txt

@@ -0,0 +1,33 @@
+= New Features
+
+* A pg_auto_parameterize_in_array extension has been added, which
+  handles conversion of IN/NOT IN to = ANY or != ALL for more types.
+  The pg_auto_parameterize extension only handles integer types by
+  default, because other types require the pg_array extension. This
+  new extension adds handling for Float, BigDecimal, Date, Time,
+  DateTime, Sequel::SQLTime, and Sequel::SQL::Blob types.  It can
+  also handle String types if the :treat_string_list_as_text_array
+  Database option is present, using the text type for that. Handling
+  String values as text is not the default because that may cause
+  issues for some queries.
+
+= Other Improvements
+
+* The defaults_setter plugin now does a deep copy of database
+  default values that are hash/array or delegates to hash/array.
+  This fixes cases where the database default values are mutated.
+
+* Sequel now correctly handles infinite and NaN float values used
+  inside PostgreSQL array bound variables.
+
+* The data in the cache files used by the schema_caching and
+  index_caching extensions and static_cache_cache and
+  pg_auto_constraint_validations plugins are now sorted before the
+  cache file is saved, increasing consistency between runs.
+
+* bigdecimal has been added as a dependency.  bigdecimal is currently
+  a default gem in Ruby from 1.9 to 3.2, but it will move to a
+  bundled gem in Ruby 3.4, and there will be warnings in Ruby 3.3
+  for cases that will break in Ruby 3.4.  Adding bigdecimal as a
+  dependency should avoid warnings when using bundler in Ruby 3.3,
+  and should avoid errors in Ruby 3.4.

data/doc/release_notes/5.73.0.txt

@@ -0,0 +1,66 @@
+= New Features
+
+* A paged_operations plugin has been added, which adds support for
+  paged_datasets, paged_update, and paged_delete dataset methods.
+  This methods are designed to be used on large datasets, to split 
+  a large query into separate smaller queries, to avoid locking the
+  related database table for a long period of time.
+  paged_update and paged_delete operate the same as update and delete,
+  returning the number of rows updated or deleted. paged_datasets yields
+  one or more datasets representing subsets of the receiver, with the
+  union of all of those datasets comprising all records in the receiver:
+
+    Album.plugin :paged_operations
+
+    Album.where{name > 'M'}.paged_datasets{|ds| puts ds.sql}
+    # Runs: SELECT id FROM albums WHERE (name <= 'M') ORDER BY id LIMIT 1 OFFSET 1000
+    # Prints: SELECT * FROM albums WHERE ((name <= 'M') AND ("id" < 1002))
+    # Runs: SELECT id FROM albums WHERE ((name <= 'M') AND (id >= 1002)) ORDER BY id LIMIT 1 OFFSET 1000
+    # Prints: SELECT * FROM albums WHERE ((name <= 'M') AND ("id" < 2002) AND (id >= 1002))
+    # ...
+    # Runs: SELECT id FROM albums WHERE ((name <= 'M') AND (id >= 10002)) ORDER BY id LIMIT 1 OFFSET 1000
+    # Prints: SELECT * FROM albums WHERE ((name <= 'M') AND (id >= 10002))
+
+    Album.where{name <= 'M'}.paged_update(:updated_at=>Sequel::CURRENT_TIMESTAMP)
+    # SELECT id FROM albums WHERE (name <= 'M') ORDER BY id LIMIT 1 OFFSET 1000
+    # UPDATE albums SET updated_at = CURRENT_TIMESTAMP WHERE ((name <= 'M') AND ("id" < 1002))
+    # SELECT id FROM albums WHERE ((name <= 'M') AND (id >= 1002)) ORDER BY id LIMIT 1 OFFSET 1000
+    # UPDATE albums SET updated_at = CURRENT_TIMESTAMP WHERE ((name <= 'M') AND ("id" < 2002) AND (id >= 1002))
+    # ...
+    # SELECT id FROM albums WHERE ((name <= 'M') AND (id >= 10002)) ORDER BY id LIMIT 1 OFFSET 1000
+    # UPDATE albums SET updated_at = CURRENT_TIMESTAMP WHERE ((name <= 'M') AND (id >= 10002))
+
+    Album.where{name > 'M'}.paged_delete
+    # SELECT id FROM albums WHERE (name > 'M') ORDER BY id LIMIT 1 OFFSET 1000
+    # DELETE FROM albums WHERE ((name > 'M') AND (id < 1002))
+    # SELECT id FROM albums WHERE (name > 'M') ORDER BY id LIMIT 1 OFFSET 1000
+    # DELETE FROM albums WHERE ((name > 'M') AND (id < 2002))
+    # ...
+    # SELECT id FROM albums WHERE (name > 'M') ORDER BY id LIMIT 1 OFFSET 1000
+    # DELETE FROM albums WHERE (name > 'M')
+
+* A Dataset#transaction :skip_transaction option is now support to
+  checkout a connection from the pool without opening a transaction.  This
+  makes it easier to handle cases where a transaction may or not be used
+  based on configuration/options.  Dataset#import and Dataset#paged_each
+  now both support the :skip_transaction option to skip transactions.
+
+* Dataset#full_text_search now supports the to_tsquery: :websearch option
+  on PostgreSQL 11+, to use the websearch_to_tsquery database function.
+
+* The Sequel::MassAssignmentRestriction exception now supports model
+  and column methods to get provide additional information about the
+  exception.  Additionally, the exception message now includes information
+  about the model class.
+
+= Other Improvements
+
+* The ibmdb and jdbc/db2 adapter now both handle disconnect errors
+  correctly, removing the related connection from the pool.
+
+* Dataset#import no longer uses an explicit transaction if given a dataset
+  value, as in that case, only a single query is used.
+
+* The column_encryption plugin no longer uses the base64 library.  The
+  base64 library is moving from the standard library to a bundled gem
+  in Ruby 3.4, and this avoids having a dependency on it.

data/doc/release_notes/5.74.0.txt

@@ -0,0 +1,45 @@
+= New Features
+
+* Sequel.migration blocks now support a revert method, which reverts
+  the changes in the block on up, and applies them on down.  So if
+  you have a migration such as:
+
+    Sequel.migration do
+      change do
+        create_table :table do
+          # ...
+        end
+      end
+    end
+
+  and you later want to add a migration that drops the table, you
+  can use:
+
+    Sequel.migration do
+      revert do
+        create_table :table do
+          # ...
+        end
+      end
+    end
+
+  This will drop the table when migrating up, and create a table 
+  with the given schema when migrating down.
+
+* 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
+  16+.  These were previously added in Sequel 5.59.0, and removed
+  in Sequel 5.61.0 as support was removed in PostgreSQL 15 beta 4.
+  PostgreSQL 16 shipped with support for them, so support has been
+  recommitted to Sequel.
+
+= Other Improvements
+
+* SQLite generated columns now show up in Database#schema when using
+  SQLite 3.37+.
+
+* Sequel now attempts to avoid an infinite loop in pathlogical cases
+  in the jdbc adapter, where the exception cause chain has a loop.
+  Additionally, if an exception is already recognized as a disconnect,
+  or an exception already responds to a getSQLState method, Sequel no
+  longer looks at the causes of the exception.

data/doc/release_notes/5.75.0.txt

@@ -0,0 +1,35 @@
+= New Features
+
+* Database#{defer,immediate}_constraints methods have been added on
+  PostgreSQL for changing handling of deferrable constraints inside
+  a transaction. defer_constraints sets deferrable constraints to
+  be deferred (not checked until transaction commit), and
+  immediate_constraints sets deferrable constraints to be checked
+  as part of the related query, and any already deferred constraint
+  checks to be applied immediately. You can pass the :constraints
+  option to only apply the changes to specific constraints.
+
+* TimestampMigrator.run_single has been added, to migrate a single
+  migration up or down.
+
+= Other Improvements
+
+* INSERT RETURNING is now supported on MariaDB 10.5+, and used
+  automatically when saving new model objects. Note that this
+  is not supported when using the jdbc adapter, because the
+  jdbc-mysql driver doesn't support it.  A jdbc/mariadb adapter
+  could be added, as it's likely recent versions of the
+  jdbc-mariadb driver would support it, but the jdbc-mariadb gem 
+  hasn't been updated in over 4 years.  Talk to the jdbc-mariadb
+  gem maintainers if you want to use this feature with the jdbc
+  adapter.
+
+* The Dataset#paged_each optimization in the postgres adapter
+  now respects the :skip_transaction option, making it the
+  same as the :hold option.  Note that this has effects beyond
+  just skipping the transaction, but non-HOLD cursors are only
+  supported inside transactions.
+
+* The any_not_empty? extension's Dataset#any? method now supports
+  an argument, passing it to Enumerable#any? (which has supported
+  an argument since Ruby 2.5).

data/doc/release_notes/5.76.0.txt

@@ -0,0 +1,86 @@
+= New Features
+
+* An auto_cast_date_and_time extension has been added, which will
+  automatically cast date and time values using SQL standard functions.
+  This makes sure the database will treat the value as a date, time,
+  or timestamp, instead of treating it as a string or unknown type:
+
+    DB.get(Date.today).class
+    # SELECT '2024-01-01' AS v LIMIT 1
+    String
+
+    DB.extension(:auto_cast_date_and_time)
+    DB.get(Date.today).class
+    # SELECT DATE '2024-01-01' AS v LIMIT 1
+    Date
+
+  This was already Sequel's default behavior on adapters that required
+  it.  This extension is usable on PostgreSQL and MySQL.  It is not
+  usable on SQLite (no date/time types) or Microsoft SQL Server (no
+  support for the SQL standard conversion syntax).
+
+  This extension can break code that currently works. If using it on
+  PostgreSQL, it will cast the values to TIMESTAMP, not TIMESTAMP
+  WITH TIME ZONE, which can break code that depended on an implicit
+  conversion to TIMESTAMP WITH TIME ZONE.  The pg_timestamptz
+  extension integrates with the the auto_cast_date_and_time extension
+  and will implicitly cast Time/DateTime to TIMESTAMP WITH TIME ZONE.
+
+* The sqlite adapter now supports a :cached value for the
+  :setup_regexp_function Database option, which will cache regexp
+  values instead of creating a new regexp per value to compare.  This
+  is much faster when using a regexp comparison on a large dataset,
+  but can result in a memory leak if using dynamic regexps. You can
+  also provide a Proc value for the :setup_regexp_function option,
+  which will be passed both the regexp source string and the database
+  string to compare, and should return whether the database string
+  matches the regexp string.
+
+* The rcte_tree plugin now supports a :union_all option, which can
+  be set to false to use UNION instead of UNION ALL in the recursive
+  common table expression.
+
+= Other Improvements
+
+* Time/DateTime/SQLTime literalization speed has more than doubled
+  compared to the previous version.  The internal code is also much
+  simpler, as the speedup resulted from removing multiple abstraction
+  layers that mostly existed for Ruby 1.8 support.
+
+* Database#table_exists? on PostgreSQL now handles lock or statement
+  timeout errors as evidence the table exists.
+
+* The round_timestamps extension now correctly rounds SQLTime values
+  on Microsoft SQL Server (the only database Sequel supports where
+  time precision is different than timestamp precision).
+
+* Fractional times and timestamps are now supported on SQLAnywhere,
+  except for time values when using the jdbc adapter due to a
+  limitation in the JDBC sqlanywhere driver.
+
+* Database#tables and #views on PostgreSQL now supports
+  SQL::Identifier values for the :schema option.
+
+* The named_timezones extension now works around a bug in DateTime.jd
+  on JRuby.
+
+= Backwards Compatibility
+
+* Time/DateTime/SQLTime literalization internals have changed.
+  If you are using an external adapter and the external adapter
+  overrides or calls any of the following methods:
+
+  * requires_sql_standard_datetimes?
+  * supports_timestamp_usecs?
+  * supports_timestamp_timezones?
+  * timestamp_precision
+  * sqltime_precision
+
+  then the adapter may need to be updated to support Sequel 5.76.0.
+  Additionally, if the adapter uses %N or %z in
+  default_timestamp_format, it may need to be updated. Adapters
+  should now just override default_timestamp_format and/or
+  default_time_format methods as appropriate for the database.
+
+* The Dataset#format_timestamp_offset private method has been
+  removed.

data/doc/release_notes/5.77.0.txt

@@ -0,0 +1,63 @@
+= New Features
+
+* A transaction_connection_validator extension has been added.  This
+  extension allows for transparently switching to a new connection if
+  a disconnect error is raised while trying to start a transaction, as
+  long as a connection was not already checked out from the pool
+  when the transaction method was called.  Transparent reconnection
+  is safe in this case, since no user code is retried.
+
+  This extension can have lower overhead than the
+  connection_validator extension if that is configured to check for
+  validity more often than the default of one hour.  However, it
+  only handles cases where transactions are used.  It can detect
+  disconnects that would not be detected by default with the
+  connection_validator extension, since that extension defaults to
+  only checking validity if the connection has not been used in the
+  last hour.
+
+* Sequel now supports a create_table :without_rowid option on SQLite,
+  to create a table WITHOUT ROWID, for better performance in some
+  cases. Users are encouraged to read the SQLite documentation on
+  WITHOUT ROWID before using this option.
+
+* The sqlite adapter now supports a :regexp_function_cache option, if
+  the :setup_regexp_function option is set to :cached.  The
+  :regexp_function_cache option should be a Proc (returning a cache
+  object to use), or a class.  It's possible to use
+  ObjectSpace::WeakKeyMap as the value of the option on Ruby 3.3+
+  to avoid the memory leaks that are possible when using
+  :setup_regexp_function option :cached value with dynamic regexps.
+
+* The duplicate_columns_handler extension now supports specifying
+  the on_duplicate_columns option as a connection string parameter.
+
+= Other Improvements
+
+* The list plugin now honors the :top option for the position when
+  adding the first item to the list, instead of always using 1.
+
+* Regexp matches on SQLite are now faster on Ruby 2.4+, using
+  Regexp#match?.
+
+* The uniqueness validation in the validation_helpers plugin now
+  uses empty? instead of count == 0, for better performance.
+
+* On Ruby 3.4+, Sequel uses the timed_queue connection pool instead
+  of the threaded connection pool by default.  This should make it
+  so no existing applications are affected by the default switch.
+  This should hopefully allow ample testing of the timed_queue
+  connection pool.  At some point in the future, if no problems
+  are repoted, Sequel will likely switch to using the timed_queue
+  connection pool by default on Ruby 3.2+.
+
+= Backwards Compatibility
+
+* Sequel now warns by default if using eager_graph/association_join
+  with an association that uses a block, in the cases where the
+  block would be ignored and there are no appropriate graph options
+  set. In Sequel 6, this warning will be turned into an exception.
+  It is recommended that users use the auto_restrict_eager_graph
+  plugin to turn this into an exception now, or use the
+  :graph_use_association_block option so that the block is not
+  ignored when graphing.

data/doc/schema_modification.rdoc

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

data/doc/security.rdoc

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

data/doc/sharding.rdoc

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

data/doc/sql.rdoc

@@ -59,7 +59,7 @@ Then, you call the +insert+, +update+, or +delete+ method on the returned datase
   update_ds.update
   delete_ds.delete
 
-+update+ and +delete+ should return the number of rows affected, and +insert+ should return the autogenerated primary key integer for the row inserted (if any).
++update+ and +delete+ generally return the number of rows affected, and +insert+ generally returns the autogenerated primary key integer for the row inserted (if any), but not all adapters/databases support this behavior for datasets using custom SQL (notably it is not supported for +insert+ on PostgreSQL).
 
 === Other Queries
 
@@ -223,22 +223,22 @@ If the database supports window functions, Sequel can handle them by calling the
   DB[:albums].select{count.function.*.over}
   # SELECT count(*) OVER () FROM albums
 
-  DB[:albums].select{function(:col1).over(:partition=>col2, :order=>col3)}
+  DB[:albums].select{function(:col1).over(partition: col2, order: col3)}
   # SELECT function(col1) OVER (PARTITION BY col2 ORDER BY col3) FROM albums
 
-  DB[:albums].select{function(c1, c2).over(:partition=>[c3, c4], :order=>[c5, c6.desc])}
+  DB[:albums].select{function(c1, c2).over(partition: [c3, c4], order: [c5, c6.desc])}
   # SELECT function(c1, c2) OVER (PARTITION BY c3, c4 ORDER BY c5, c6 DESC) FROM albums
 
-  DB[:albums].select{function(c1).over(:partition=>c2, :order=>:c3, :frame=>:rows)}
+  DB[:albums].select{function(c1).over(partition: c2, order: :c3, frame: :rows)}
   # SELECT function(c1) OVER (PARTITION BY c2 ORDER BY c3 ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) FROM albums
 
-  DB[:albums].select{function(c1).over(:partition=>c2, :order=>:c3, :frame=>{:type=>:range, :start=>1, :end=>1})}
+  DB[:albums].select{function(c1).over(partition: c2, order: :c3, frame: {type: :range, start: 1, end: 1})}
   # SELECT function(c1) OVER (PARTITION BY c2 ORDER BY c3 RANGE BETWEEN 1 PRECEDING AND 1 FOLLOWING) FROM albums
 
-  DB[:albums].select{function(c1).over(:partition=>c2, :order=>:c3, :frame=>{:type=>:groups, :start=>[2, :preceding], :end=>[1, :preceding]})}
+  DB[:albums].select{function(c1).over(partition: c2, order: :c3, frame: {type: :groups, start: [2, :preceding], end: [1, :preceding]})}
   # SELECT function(c1) OVER (PARTITION BY c2 ORDER BY c3 GROUPS BETWEEN 2 PRECEDING AND 1 PRECEDING) FROM albums
 
-  DB[:albums].select{function(c1).over(:partition=>c2, :order=>:c3, :frame=>{:type=>:range, :start=>:preceding, :exclude=>:current})}
+  DB[:albums].select{function(c1).over(partition: c2, order: :c3, frame: {type: :range, start: :preceding, exclude: :current})}
   # SELECT function(c1) OVER (PARTITION BY c2 ORDER BY c3 RANGE UNBOUNDED PRECEDING EXCLUDE CURRENT ROW) FROM albums
 
 === Schema Qualified Functions
@@ -428,6 +428,18 @@ As you can see, these literalize with ANDs by default.  You can use the <tt>Sequ
 
   Sequel.or(column1: 1, column2: 2) # (("column1" = 1) OR ("column2" = 2))
 
+As you can see in the above examples, <tt>Sequel.|</tt> and <tt>Sequel.or</tt> work differently.
+<tt>Sequel.|</tt> is for combining an arbitrary number of expressions using OR. If you pass a single
+argument, <tt>Sequel.|</tt> will just convert it to a Sequel expression, similar to <tt>Sequel.expr</tt>.
+<tt>Sequel.or</tt> is for taking a single hash or array of two element arrays and combining the
+elements of that single argument using OR instead of AND:
+
+  Sequel.|(column1: 1, column2: 2) # (("column1" = 1) AND ("column2" = 2))
+  Sequel.or(column1: 1, column2: 2) # (("column1" = 1) OR ("column2" = 2))
+
+  Sequel.|({column1: 1}, {column2: 2}) # (("column1" = 1) OR ("column2" = 2))
+  Sequel.or({column1: 1}, {column2: 2}) # ArgumentError
+
 You've already seen the <tt>Sequel.negate</tt> method, which will use ANDs if multiple entries are used:
 
   Sequel.negate(column1: 1, column2: 2) # (("column1" != 1) AND ("column2" != 2))
@@ -516,7 +528,7 @@ Inverting the LIKE operator works like other inversions:
 
   ~Sequel.like(:name, 'A%') # ("name" NOT LIKE 'A%' ESCAPE '\')
 
-Sequel also supports SQL regular expressions on MySQL and PostgreSQL.  You can use these by passing a Ruby regular expression to +like+ or +ilike+, or by making the regular expression a hash value:
+Sequel also supports SQL regular expressions on MySQL and PostgreSQL (and SQLite when using the sqlite adapter with the :setup_regexp_function Database option).  You can use these by passing a Ruby regular expression to +like+ or +ilike+, or by making the regular expression a hash value:
 
   Sequel.like(:name, /^A/) # ("name" ~ '^A')
   ~Sequel.ilike(:name, /^A/) # ("name" !~* '^A')
@@ -539,8 +551,8 @@ You can also use the <tt>Sequel.asc</tt> and <tt>Sequel.desc</tt> methods:
 
 On some databases, you can specify null ordering:
 
-  Sequel.asc(:column, :nulls=>:first) # "column" ASC NULLS FIRST
-  Sequel.desc(Sequel[:table][:column], :nulls=>:last) # "table"."column" DESC NULLS LAST
+  Sequel.asc(:column, nulls: :first) # "column" ASC NULLS FIRST
+  Sequel.desc(Sequel[:table][:column], nulls: :last) # "table"."column" DESC NULLS LAST
 
 === All Columns (.*)
 
@@ -617,16 +629,16 @@ Also note that while the SELECT clause is displayed when you look at a dataset,
 
   ds = DB[:albums]
   ds.all # SELECT * FROM albums
-  ds.insert(:name=>'RF') # INSERT INTO albums (name) VALUES ('RF')
-  ds.update(:name=>'RF') # UPDATE albums SET name = 'RF'
+  ds.insert(name: 'RF') # INSERT INTO albums (name) VALUES ('RF')
+  ds.update(name: 'RF') # UPDATE albums SET name = 'RF'
   ds.delete # DELETE FROM albums
 
 In general, the +insert+, +update+, and +delete+ methods use the appropriate clauses you defined on the dataset:
 
-  ds = DB[:albums].where(:id=>1)
+  ds = DB[:albums].where(id: 1)
   ds.all # SELECT * FROM albums WHERE (id = 1)
-  ds.insert(:name=>'RF') # INSERT INTO albums (name) VALUES ('RF')
-  ds.update(:name=>'RF') # UPDATE albums SET name = 'RF' WHERE (id = 1)
+  ds.insert(name: 'RF') # INSERT INTO albums (name) VALUES ('RF')
+  ds.update(name: 'RF') # UPDATE albums SET name = 'RF' WHERE (id = 1)
   ds.delete # DELETE FROM albums WHERE (id = 1)
 
 Note how +update+ and +delete+ used the +where+ argument, but +insert+ did not, because INSERT doesn't use a WHERE clause.