sequel 5.8.0 → 5.38.0

data/doc/release_notes/5.32.0.txt

@@ -0,0 +1,46 @@
+= New Features
+
+* A fiber_concurrency extension has been added, for using
+  Fiber.current instead of Thread.current when checking out a
+  connection.  This allows separate fibers of the same thread
+  to use separate connections.  In addition to allowing direct use
+  of fibers, this also allows concurrent use of multiple enumerators
+  that use database connections in the same thread.
+
+  When using this extension, you must be careful and ensure that you
+  are not using more concurrent fibers than your connection pool size.
+  Otherwise, all fibers will block while one fiber waits until a
+  connection is available.  It is possible this issue will be
+  addressed when Ruby implements a fiber scheduler (currently
+  being discussed for inclusion in Ruby 3).
+
+* A run_transaction_hooks Database extension has been added,
+  allowing for running the transaction hooks before commit/rollback,
+  which can be helpful for testing the hooks when using transactional
+  testing.
+
+= Other Improvements
+
+* Database#create_table? now works correctly with the :partition_of
+  option on PostgreSQL.
+
+* The timestamp(N) with time zone type is now recognized by the
+  schema parser.
+
+* Singleton methods of the Sequel module have now been moved into a
+  Sequel::SequelMethods module.  This allows you to extend Sequel
+  with a module that overrides the methods and call super to get
+  the default behavior.
+
+* The pg_inet extension no longer defines inet/cidr conversion procs
+  if sequel_pg 1.13.0+ is in use.  This is because sequel_pg 1.13.0+
+  will respect the conversion procs and defining them makes things
+  slower.  sequel_pg 1.13.0+ handles the same conversion by default
+  without needing a conversion proc.
+
+* Method visibility issues in the model, plugin, extension, and adapter
+  code have been fixed.  Most cases fixed were private methods being
+  accidentally made public when they were overridden.
+
+  During this change, Model#_insert_values was changed from public to
+  private, since it was originally intended to be private.

data/doc/release_notes/5.33.0.txt

@@ -0,0 +1,24 @@
+= New Features
+
+* Custom join types are now supported on a per-association basis when
+  using eager_graph/association_join.  This builds on the previous
+  support for custom aliases, using Sequel::SQL::AliasedExpression:
+
+    class Artist < Sequel::Model; end
+    class Album < Sequel::Model; end
+    class Track < Sequel::Model; end
+    Artist.one_to_many :albums
+    Album.one_to_many :tracks
+    Artist.eager_graph(
+      Sequel[:albums].as(:a, join_type: :inner) =>
+        Sequel[:tracks].as(:t, join_type: :left)
+    )
+
+* A Database#current_timestamp_utc accessor has been added on SQLite.
+  Setting this to true will keep CURRENT_TIMESTAMP, CURRENT_TIME, and
+  CURRENT_DATE in UTC instead of converting them to localtime.
+
+= Other Improvements
+
+* The smallserial PostgreSQL type is now recognized and Sequel will
+  not try to mark smallserial columns as identity columns.

data/doc/release_notes/5.34.0.txt

@@ -0,0 +1,40 @@
+= New Features
+
+* The association_pks plugin now creates *_pks_dataset methods for
+  each association.  These are similar to the existing *_pks getter
+  methods, but they return a dataset of the keys instead of the keys
+  themselves.
+
+* The association_pks plugin now supports a :cache_pks association
+  option, which will cache calls to the *_pks getter method. The
+  default behavior remains that the *_pks getter method only returns
+  cached values if the *_pks= setter method has been used to set the
+  values.
+
+* The *_pks getter methods supported by the association_pks plugin
+  now support a :refresh option to ignore any cached values, similar
+  to how the association getter methods work.
+
+= Other Improvements
+
+* If trying to disconnect a server that doesn't exist when using a
+  sharded connection pool, a Sequel::Error is now raised.  Previously,
+  the sharded threaded pool raised a NoMethodError and the sharded
+  single connection pool did not raise an error.
+
+* If using the :savepoint option when savepoints are not supported,
+  a Sequel::InvalidOperation exception is now raised, instead of a
+  NoMethodError.
+
+* Calling Dataset#eager_graph with no arguments now returns the
+  dataset.
+
+* If not connected to the database, the single connection pool will
+  not yield any connections to Database#pool.all_connections.
+
+* Forcing a :ruby eager limit strategy for an association without a
+  limit or offset now works correctly.
+
+* Multiple unnecessary conditionals have been removed.
+
+* Sequel core and model code now have 100% branch coverage.

data/doc/release_notes/5.35.0.txt

@@ -0,0 +1,56 @@
+= New Features
+
+* An instance_specific_default plugin has been added for setting the
+  default for the :instance_specific association option, or
+  warning/raises in cases where it is not specified.  This allows
+  you to easily find associations that would be considering instance
+  specific by default, and mark them as not instance specific for
+  better performance.
+
+= Other Improvements
+
+* Setting the :instance_specific association option to false now
+  works correctly if the association uses a block.  Associations
+  that set the :dataset option are now always considered instance
+  specific, even if the :instance_specific option is explicitly
+  passed.
+
+* The validation_class_methods plugin now considers all :if,
+  :allow_missing, :allow_nil, and :allow_blank options.  Previously,
+  it only considered the first of those options that was set.
+
+* Model.finalize_associations no longer breaks if you have
+  instance-specific associations.
+
+* Model.plugin now warns if you load the plugin with arguments or a
+  block if the plugin does not accept arguments or block.  This is
+  because a future change to Sequel could break the call.
+
+* When emulating unsupported alter table operations on SQLite, Sequel
+  now copies composite unique constraints unless the alter table
+  operation is the dropping of a unique constraint.
+
+* Sequel now recognizes an additional disconnect error in the oracle
+  adapter.
+
+* In the run_transaction_hooks extension, calling
+  run_after_{commit,rollback}_hooks now raises the correct exception
+  class.
+
+* In the pg_range extension, conversion procs for the tsrange[] and
+  tstzrange[] types are not added unless the Database uses the
+  pg_array extension.
+
+* Multiple unnecessary conditionals in plugins and extensions have
+  been removed.
+
+* Sequel plugin and extension code now have 100% branch coverage.
+
+* Sequel now avoids a statement not reached verbose warning in
+  Dataset#clone.
+
+= Backwards Compatibility
+
+* The output of Dataset#to_dot in the to_dot extension has changed
+  slightly, including hash entries with nil keys.  These entries
+  were previously ignored.

data/doc/release_notes/5.36.0.txt

@@ -0,0 +1,60 @@
+= New Features
+
+* Dataset#with_ties has been added on PostgreSQL 13+ and Microsoft
+  SQL Server, which will have a limited dataset also return all
+  rows with the same order as the final row.
+
+* In the pg_json_ops extension, the following methods have been
+  added to Postgres::JSONBOp, all of which require PostgreSQL 13+:
+  
+  * #set_lax
+  * #path_exists_tz!
+  * #path_match_tz!
+  * #path_query_tz
+  * #path_query_array_tz
+  * #path_query_first_tz
+
+* On Oracle, the Database#view_exists? method now accepts a
+  :current_schema option to limit the views returned to the
+  current schema, instead of all non-system schemas.
+
+= Other Improvements
+
+* Sequel will now pass keyword arguments through in the following
+  cases:
+
+  * When loading plugins (Model.plugin)
+
+  * Class methods automically defined for methods defined in a
+    Model.dataset_module block
+
+  * Methods defined by Plugins.def_dataset_method
+
+  * Database methods called inside migrations
+
+  * Methods called via an association proxy when using the
+    association_proxies plugin.
+
+  * Dataset methods called inside a Dataset#query block when using
+    the query extension.
+
+  Previously, keywords were not handled in these cases, which would
+  cause deprecation warnings in Ruby 2.7 and ArgumentErrors in Ruby
+  3.0.  Note that Sequel itself does not use keyword arguments at
+  all, so all of these changes only affect cases where external
+  methods are defined that accept keywords, and Sequel methods are
+  called with keywords that end up being delegated to the external
+  methods.
+
+* The odbc adapter will now stream result sets instead of loading
+  the entire result set in memory and then iterating over it.
+
+* Sequel now recognizes another disconnect error in the mysql and
+  mysql2 adapters.
+
+= Backwards Compatibility
+
+* Due to the odbc adapter change to use streaming, issuing queries
+  inside a Dataset#each block will no longer work unless a different
+  shard or thread is used.  The behavior of such code is considered
+  undefined on all Sequel adapters.

data/doc/release_notes/5.37.0.txt

@@ -0,0 +1,30 @@
+= New Features
+
+* Model#column_previously_was and #column_previously_changed? have
+  been added to the dirty plugin, for getting the previous values
+  of the column before saving and for whether there were changes
+  before saving.
+  
+  Model#column_previously_changed? accepts :from and :to options
+  to allow you to more easily determine if the value changed from
+  and/or to specific values.
+
+  This information was previously obtainable via
+  Model#previous_changes, but these new methods offer a friendlier
+  interface.
+
+* Postgres::PGRow::{Array,Hash}Row#op has been added to the
+  pg_row_ops extension if the pg_row extension is loaded.  This
+  is similar to how the pg_array_ops, pg_hstore_ops, and
+  pg_json_ops and #op method to their objects.  This makes it
+  easier to perform row operations on literal rows.
+
+= Other Improvements
+
+* The schema_dumper extension now supports more unsigned numeric
+  types, such as "decimal(7,2) unsigned" and "real unsigned".
+
+* IntegerMigrator now raises an Migrator::Error if attempting to
+  migrate down when there are migration files missing and needed for
+  the down migration.  Previously, IntegerMigrator would not raise an
+  exception and would make no database changes in this case.

data/doc/release_notes/5.38.0.txt

@@ -0,0 +1,28 @@
+= New Features
+
+* The jdbc/mysql adapter now supports the newer
+  com.mysql.cj.jdbc.Driver driver.  The adapter will still attempt to
+  load the older com.mysql.jdbc.Driver if the com.mysql.cj.jdbc.Driver
+  is not found.
+
+= Other Improvements
+
+* When testing a connection after creating a new Database instance
+  raises an exception, the Database instance is removed from
+  Sequel::DATABASES.
+
+* The single_table_inheritance and prepared_statements plugins now
+  work correctly if loaded into the same class.
+
+* Database connect and disconnect errors are no longer swallowed when
+  calling Database#create_or_replace_view, Database#server_version
+  on PostgreSQL, or Database#create_table* on Oracle.
+
+= Backwards Compatibility
+
+* Previously, instantiating a new Database instance directly using
+  Sequel::Database.new did not test the connection by default.  That
+  was instead handled by Sequel::Database.connect.  The test
+  connection now happens inside Database#initialize.  This should only
+  affect backwards compatibility for code that is calling
+  Sequel::Database.new directly.

data/doc/release_notes/5.9.0.txt

@@ -0,0 +1,99 @@
+= New Features
+
+* An escaped_like extension has been added, for the creation of
+  LIKE/ILIKE expressions with placeholders in patterns without
+  access to a dataset.  This adds escaped_like and escaped_ilike
+  methods to the same Sequel expression objects that support like
+  and ilike.  These methods take two arguments, the first being
+  the pattern, with ? placeholders, and the second being the
+  placeholder value (which can be an array for multiple
+  placeholders):
+
+    Sequel.extension :escaped_like
+    DB[:table].where{string_column.escaped_like('?%', user_input)}
+    # user_input is 'foo':
+    #  SELECT * FROM table WHERE string_column LIKE 'foo%'
+    # user_input is '%foo':
+    #  SELECT * FROM table WHERE string_column LIKE '\%foo%'
+
+* Generated columns on MySQL 5.7+ and MariaDB 5.2+ are now supported
+  using the :generated_always_as option when creating the column.
+  The :generated_type option can also be used to specify the type of
+  generated column (virtual or stored).  Examples:
+
+    DB.add_column :t, :c, Integer, generated_always_as: Sequel[:a]+'b'
+    # ALTER TABLE `t` ADD COLUMN `c` varchar(255)
+    # GENERATED ALWAYS AS (CONCAT(`a`, 'b'))
+
+    DB.add_column :t, :c, Integer, generated_always_as: Sequel[:a]+'b',
+      generated_type: :virtual
+    # ALTER TABLE `t` ADD COLUMN `c` varchar(255)
+    # GENERATED ALWAYS AS (CONCAT(`a`, 'b')) VIRTUAL
+
+    DB.add_column :t, :c, Integer, generated_always_as: Sequel[:a]+'b',
+      generated_type: :stored
+    # ALTER TABLE `t` ADD COLUMN `c` varchar(255)
+    # GENERATED ALWAYS AS (CONCAT(`a`, 'b')) STORED
+
+* Sequel::Model.has_dataset? has been added for checking whether the
+  model class has an associated dataset.  This will generally be true
+  for most model classes, but will be false for abstract model
+  classes (such as Sequel::Model itself).
+
+* Sequel::VERSION_NUMBER has been added for easier future version
+  comparisons.  The version number for 5.9.0 is 50090.
+
+= Other Improvements
+
+* When disconnecting connections in the threaded connection pools,
+  the disconnection is performed without holding the connection
+  pool mutex, since disconnection may block.
+
+* The sharded threaded connection pool no longer deadlocks when
+  disconnecting connections if the connection_validator or
+  connection_expiration extension is used.
+
+* If a thread dies and does not check a connection back into the
+  connection pool, Sequel now disconnects the connection when it
+  detects the dead thread, instead of assuming the connection is
+  safe to be reused.
+
+* When using eager_graph with cascaded associations, a unique
+  object is now used instead of a shared object in cases where
+  using a shared object may cause further cascaded associated
+  objects to be duplicated.
+
+* On PostgreSQL, the ESCAPE modifier to the LIKE/ILIKE operators is
+  no longer used, since the default ESCAPE value is the one Sequel
+  uses.  This change was made in order to allow the LIKE/ILIKE
+  operators to work with the ANY function, as PostgreSQL does not
+  support the use of the ESCAPE modifier in such cases.
+
+* A hash argument passed to Model.nested_attributes in the
+  nested_attributes plugin is now no longer modified.
+
+* Internal data structures for eager and eager_graph datasets are now
+  frozen to avoid unintentional modification.
+
+* Nondeterministic behavior in Database#foreign_key_list with the
+  :reverse option on PostgreSQL is now avoided by using an
+  unambiguous order.
+
+* Performance has been improved slightly by avoiding unnecessary
+  hash allocations.
+
+* Performance has been improved slightly by using while instead
+  of Kernel#loop.
+
+* BigDecimal() is now used instead of BigDecimal.new(), as the
+  latter has been deprecated.
+
+* The jdbc adapter now avoids referencing ::NativeException on JRuby
+  9.2+, since JRuby has deprecated it.  It is still used on older
+  versions of JRuby, since some JRuby 1.7 code may still require it.
+
+* Sequel now works around multiple Date/Time conversion bugs in
+  JRuby 9.2.0.0 for BC dates in the pg_extended_date_support
+  extension.  These bugs have already been fixed in JRuby, and
+  the workarounds will be removed after the release of JRuby
+  9.2.1.0.

data/doc/security.rdoc

@@ -173,6 +173,16 @@ user input for function names.
 
   DB[:table].select(Sequel.function(params[:id])) # SQL injection!
 
+==== SQL Window Frames
+
+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')}
+
+You should make sure the frame argument is not derived from user input,
+or switch to using a hash as the :frame option value.
+
 ==== auto_literal_strings extension
 
 If the auto_literal_strings extension is used for backwards compatibility,

data/doc/sharding.rdoc

@@ -1,7 +1,7 @@
-= Read-Only Slaves/Writable Master and Database Sharding
+= Primary/Replica Configurations and Database Sharding
 
-Sequel has support for read only slave databases
-with a writable master database, as well as database sharding (where you can
+Sequel has support for primary/replica configurations (writable primary
+database with read only replicas databases), as well as database sharding (where you can
 pick a server to use for a given dataset).  Support for both
 features is database independent, and should work for all database adapters
 that ship with Sequel.
@@ -13,7 +13,7 @@ option.  Using the :servers database option makes Sequel use a connection pool
 class that supports sharding, and the minimum required to enable sharding
 support is to use the empty hash:
 
-  DB=Sequel.connect('postgres://master_server/database', servers: {})
+  DB=Sequel.connect('postgres://primary_server/database', servers: {})
 
 In most cases, you are probably not going to want to use an empty hash.  Keys in the server hash are
 not restricted to type, but the general recommendation is to use a symbol
@@ -28,69 +28,69 @@ a :host entry in each shard's hash.
 Note that all servers should have the same schema for all
 tables you are accessing, unless you really know what you are doing.
 
-== Master and Slave Database Configurations
+== Primary and Replica Database Configurations
 
-=== Single Read-Only Slave, Single Master
+=== Single Primary, Single Replica
 
-To use a single, read-only slave that handles SELECT queries, the following
+To use a single, read-only replica that handles SELECT queries, the following
 is the simplest configuration:
 
-  DB=Sequel.connect('postgres://master_server/database', 
-    servers: {read_only: {host: 'slave_server'}})
+  DB=Sequel.connect('postgres://primary_server/database', 
+    servers: {read_only: {host: 'replica_server'}})
 
-This will use the slave_server for SELECT queries and master_server for
+This will use the replica_server for SELECT queries and primary_server for
 other queries.
 
 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 
 the symbol name defined in the connect options. For example:
 
-  # Force the SELECT to run on the master
+  # Force the SELECT to run on the primary server
   DB[:users].server(:default).all
 
-  # Force the DELETE to run on the read-only slave
+  # Force the DELETE to run on the read-only replica
   DB[:users].server(:read_only).delete
 
-=== Multiple Read-Only Slaves, Single Master
+=== Single Primary, Multiple Replicas
 
-Let's say you have 4 slave database servers with names slave_server0,
-slave_server1, slave_server2, and slave_server3.
+Let's say you have 4 replica servers with names replica_server0,
+replica_server1, replica_server2, and replica_server3.
 
   num_read_only = 4
   read_only_host = rand(num_read_only)
   read_only_proc = proc do |db|
-    {host: "slave_server#{(read_only_host+=1) % num_read_only}"}
+    {host: "replica_server#{(read_only_host+=1) % num_read_only}"}
   end
-  DB=Sequel.connect('postgres://master_server/database',
+  DB=Sequel.connect('postgres://primary_server/database',
     servers: {read_only: read_only_proc})
 
-This will use one of the slave servers for SELECT queries and use the
-master server for other queries.  It's also possible to pick a random host
+This will use one of the replica servers for SELECT queries and use the
+primary server for other queries.  It's also possible to pick a random host
 instead of using the round robin approach presented above, but that can result
 in less optimal resource usage.
 
-=== Multiple Read-Only Slaves, Multiple Masters
+=== Multiple Primary, Multiple Replicas
 
-This involves the same basic idea as the multiple slaves, single master, but
-it shows that the master database is named :default.  So for 4 masters and
-4 slaves:
+This involves the same basic idea as the multiple replicas, single primary, but
+it shows that the primary database is named :default.  So for 4 primary servers and
+4 replica servers:
 
   num_read_only = 4
   read_only_host = rand(num_read_only)
   read_only_proc = proc do |db|
-    {host: "slave_server#{(read_only_host+=1) % num_read_only}"}
+    {host: "replica_server#{(read_only_host+=1) % num_read_only}"}
   end
   num_default = 4
   default_host = rand(num_default)
   default_proc = proc do |db|
-    {host: "master_server#{(default_host+=1) % num_default}"}
+    {host: "primary_server#{(default_host+=1) % num_default}"}
   end
-  DB=Sequel.connect('postgres://master_server/database',
+  DB=Sequel.connect('postgres://primary_server/database',
     servers: {default: default_proc, read_only: read_only_proc})
   
 == Sharding
 
-There is specific support in Sequel for handling master/slave database
+There is specific support in Sequel for handling primary/replica database
 combinations, with the only necessary setup being the database configuration.
 However, since sharding is always going to be implementation dependent, Sequel
 supplies the basic infrastructure, but you have to tell it which server to use
@@ -140,6 +140,8 @@ the shard to use.  This is fairly easy using a Sequel::Model:
   
   Rainbow.plaintext_for_hash("e580726d31f6e1ad216ffd87279e536d1f74e606")
 
+=== :servers_hash Option
+
 The connection pool can be further controlled to change how it handles attempts
 to access shards that haven't been configured.  The default is
 to assume the :default shard.  However, you can specify a
@@ -210,7 +212,7 @@ need to do that, call the server method explicitly on the dataset used to retrie
 model objects.
 
 The with_server method also supports a second argument for the default read_only server
-to use, which can be useful if you are mixing sharding and master/slave servers:
+to use, which can be useful if you are mixing sharding and primary/replica servers:
 
   DB.extension :server_block
   DB.with_server(:a, :a_read_only) do
@@ -268,3 +270,15 @@ the Database, just remove that option.  If you are setting:
   Sequel.single_threaded = true 
 
 just remove or comment out that code.
+
+== JDBC
+
+If you are using the jdbc adapter, note that it does not handle separate
+options such as +:host+, +:user+, and +:port+.  If you would like to use
+the +:servers+ option when connecting to a JDBC database, each hash value in
+the +servers+ option should contain a +:uri+ key with a JDBC connection string
+for that shard as the value.  Example:
+
+  DB=Sequel.connect('jdbc:postgresql://primary_server/database', 
+    servers: {read_only: {uri: 'jdbc:postgresql://replica_server/database'}})
+