sequel 5.20.0 → 5.49.0

data/doc/release_notes/5.31.0.txt

@@ -0,0 +1,148 @@
+= New Features
+
+* A forbid_lazy_load plugin has been added to forbid the lazy loading
+  of model associations if the current object was retreived with other
+  objects.  This plugin helps detect N+1 query issues.  This plugin
+  will raise an error if a lazy load is detected in such cases:
+
+    Album.plugin :forbid_lazy_load
+    Album.one_to_many :tracks
+
+    Album.each do |album|
+      album.tracks
+      # Could be N+1, raises Sequel::Plugins::ForbidLazyLoad::Error
+    end
+
+    Album.first.tracks
+    # Could not be N+1, no error raised
+
+  The forbid_lazy_load plugin is designed to be loaded into the base
+  model class (generally Sequel::Model), and can be loaded only in
+  test mode, or only in certain test mode configurations, so that it
+  does not have any production performance impact.
+
+  Note that an alternative approach that Sequel has supported for many
+  years is the tactical_eager_loading plugin, which automatically
+  eager loads when an N+1 query issue is detected.
+
+* An association_lazy_eager_option plugin has been added which supports
+  the :eager option for the association method.  If the association has
+  not been loaded, this eagerly loads the associations specified by the
+  :eager option when loading the association.  If the association has
+  already been loaded, this option is ignored, with the assumption that
+  whatever loaded the association already used the correct eager
+  loading.  Example:
+
+    Album.plugin :association_lazy_eager_option
+    Album.one_to_many :tracks
+    Track.many_to_one :artist
+
+    album = Album.first
+    album.tracks(:eager=>:artist)
+    # Loads tracks for album, then artist for each track (2 queries)
+
+    album.tracks(:eager=>:artist)
+    # No query issued as association is cached
+
+  You could previously have similar behavior for uncached associations
+  by passing a block to the association method and calling eager on
+  the yielded dataset.  However, that would ignore any cached
+  association, causing redundant loading of the association in such
+  cases.
+
+* On PostgreSQL 10+, creating partitioned tables and partitions of
+  other tables is now supported.
+
+  To create a partitioned table, use the :partition_by option:
+
+    DB.create_table(:table1, partition_by: :date_column,
+                            partition_type: :range) do
+      Integer :id
+      Date :date_column
+    end
+
+    DB.create_table(:table2, partition_by: :string_column,
+                             partition_type: :list) do
+      Integer :id
+      String :string_column
+    end
+
+    DB.create_table(:table3, partition_by: :int_column,
+                             partition_type: :hash) do
+      Integer :id
+      Integer :int_column
+    end
+
+  To add partitions of other tables, use the :partition_of option.
+  This option will use a custom DSL specific to partitions of other
+  tables.
+  
+  For range partitioning, you can use the from and to methods to
+  specify the inclusive beginning and exclusive ending of the range
+  of the partition.  You can call the minvalue and maxvalue methods
+  to get the minimum and maximum values for the column(s) in the
+  range, useful as arguments to from and to:
+
+    DB.create_table(:table1a, partition_of: :table1) do
+      from minvalue
+      to 0
+    end
+    DB.create_table(:table1b, partition_of: :table1) do
+      from 0
+      to 100
+    end
+    DB.create_table(:table1c, partition_of: :table1) do
+      from 100
+      to maxvalue
+    end
+
+  For list partitioning, you use the values_in method.  You can also
+  use the default method to mark a partition as the default partition:
+
+    DB.create_table(:table2a, partition_of: :table2) do
+      values_in 1, 2, 3
+    end
+    DB.create_table(:table2b, partition_of: :table2) do
+      values_in 4, 5, 6
+    end
+    DB.create_table(:table2c, partition_of: :table2) do
+      default
+    end
+
+  For hash partitioning, you use the modulus and remainder methods:
+
+    DB.create_table(:table3a, partition_of: :table3) do
+      modulus 3
+      remainder 0
+    end
+    DB.create_table(:table3b, partition_of: :table3) do
+      modulus 3
+      remainder 1
+    end
+    DB.create_table(:table3c, partition_of: :table3) do
+      modulus 3
+      remainder 2
+    end
+
+* On PostgreSQL 12+ and SQLite 3.31+, column schema hashes now have
+  a :generated entry for whether the column is a generated column.
+
+* The schema_dumper extension now dumps generated columns correctly
+  when using the :same_db option on PostgreSQL 12+.
+
+* A skip_saving_columns plugin has been added.  This allows skipping
+  saving of specific columns for the model.  By default, it skips
+  saving of generated columns, but you can customize the columns
+  that it skips:
+
+    Album.plugin :skip_saving_columns
+    Album.skip_saving_columns = [:some_column]
+
+= Other Improvements
+
+* The alter_table drop_constraint :primary_key option on SQLite now
+  works correctly for non-integer primary keys.
+
+* When an error is raised due to an irreversible migration, the error
+  message now includes the file containing the migration for easier
+  debugging.

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.39.0.txt

@@ -0,0 +1,19 @@
+= New Features
+
+* On Microsoft SQL Server, the :clustered option is now supported
+  for primary key and unique constraints.  You can use a true value
+  for CLUSTERED and a false value for NONCLUSTERED.
+
+= Other Improvements
+
+* Partitioned tables are now included in the result of
+  Database#tables on PostgreSQL.
+
+* alter_table set_column_allow_null no longer drops the size of
+  binary columns on Microsoft SQL Server.
+
+* In the tree plugin, the roots_dataset method now works correctly
+  with queries using joins by qualifying the parent column.
+
+* A fork safety guide has been added, discussing fork safety issues
+  when using Sequel.

data/doc/release_notes/5.40.0.txt

@@ -0,0 +1,40 @@
+= New Features
+
+* On SQLite 3.33.0+, the UPDATE FROM syntax is now supported. This
+  allows you to update one table based on a join to another table.
+  The SQLite syntax is based on the PostgreSQL syntax, and the
+  Sequel API is the same for both.  You need to pass multiple tables
+  to Dataset#from.  The first table is the table to update, and the
+  remaining tables are used to construct the UPDATE FROM clause:
+
+    DB[:a, :b].where{{a[:c]=>b[:d]}}.update(:e=>'f')
+    # UPDATE a SET e = 'f' FROM b WHERE (a.c = b.d)
+
+  Unlike PostgreSQL, SQLite does not support the deletion of joined
+  datasets.  Related to this, the following methods for testing
+  database support for modifying joined datasets have been added:
+
+  * supports_updating_joins?
+  * supports_deleting_joins?
+
+= Other Improvements
+
+* The pg_interval and date_arithmetic extensions now support
+  ActiveSupport 6.1.
+
+* Sequel no longer issues method redefinition warnings in verbose
+  mode.  As Ruby 3 has dropped uninitialized instance variable
+  warnings, Sequel is now verbose warning free on Ruby 3.
+
+= Backwards Compatibility
+
+* Trying to truncate or insert into a joined dataset now correctly
+  raises an exception even if the joined dataset supports updates.
+
+* The private Dataset#check_modification_allowed! method is now
+  deprecated, and users (custom adapters) should now switch to one
+  of the more specific methods introduced in this version:
+
+  * check_insert_allowed!
+  * check_update_allowed!
+  * check_delete_allowed!

data/doc/release_notes/5.41.0.txt

@@ -0,0 +1,25 @@
+= New Features
+
+* The validation methods added by the validation_helpers plugin now
+  support the :skip_invalid option, which will not add a validation
+  error on a column if it already has a validation error.  This can
+  be useful if you want to avoid having duplicate errors.
+
+* The auto_validations plugin now supports a :skip_invalid plugin
+  option, which will pass the :skip_invalid option when calling
+  validation methods.
+
+= Other Improvements
+
+* The :adder, :remover, and :clearer association options now
+  support keyword arguments in Ruby 2.7+.
+
+* In the pg_interval extension, Sequel now uses the same number of
+  seconds per month and seconds per year as active_support.  It
+  originally used the same number, but active_support changed the
+  values in active_support 5.1.  Sequel now uses the active_support
+  values if they are available.
+
+* When adding a String column on PostgreSQL, an explicit text: true
+  option now takes precedence over an explicit :size option, as it
+  does in Sequel's default behavior.

data/doc/release_notes/5.42.0.txt

@@ -0,0 +1,136 @@
+= New Features
+
+* An async_thread_pool Database extension has been added, which
+  executes queries and processes results using a separate thread
+  pool.  This allows you do do things like:
+
+    foos = DB[:foos].async.all
+    bars = DB[:bars].async.select_map(:name)
+    foo_bars = DB[:foo_bars].async.each{|x| p x}
+
+  and have the three method calls (all, select_map, and each)
+  execute concurrently.  On Ruby implementations without a global
+  VM lock, such as JRuby, it will allow for parallel execution of
+  the method calls.  On CRuby, the main benefit will be for cases
+  where query execution takes a long time or there is significant
+  latency between the application and the database.
+  
+  When you call a method on foos, bars, or foo_bars, if the thread
+  pool hasn't finished processing the method, the calling code will
+  block until the method call has finished.
+
+  By default, for consistency, calling code will not preempt the
+  async thread pool.  For example, if you do:
+
+    DB[:foos].async.all.size
+
+  The calling code will always wait for the async thread pool to
+  run the all method, and then the calling code will call size on
+  the result.  This ensures that async queries will not use the
+  same connection as the the calling thread, even if calling thread
+  has a connection checked out.
+
+  In some cases, such as when the async thread pool is very busy,
+  preemption is desired for performance reasons.  If you set the
+  :preempt_async_thread Database option before loading the
+  async_thread_pool extension, preemption will be allowed.  With
+  preemption allowed, if the async thread pool has not started the
+  processing of the method at the time the calling code needs the
+  results of the method, the calling code will preempt the async
+  thread pool, and run the method on the current thread.
+
+  By default, the async thread pool uses the same number of threads as
+  the Database objects :max_connections attribute (the default for
+  that is 4).  You can modify the number of async threads by setting
+  the :num_async_threads Database option before loading the Database
+  async_thread_pool extension.
+
+  Most Dataset methods that execute queries on the database and return
+  results will operate asynchronously if the the dataset is set to be
+  asynchronous via the Dataset#async method.  This includes most
+  methods available due to the inclusion in Enumerable, even if not
+  defined by Dataset itself.
+
+  There are multiple caveats when using the async_thread_pool
+  extension:
+  
+  * Asynchronous behavior is harder to understand and harder to
+    debug.  It would be wise to only use this support in cases where
+    it provides is significant performance benefit.
+
+  * Dataset methods executed asynchronously will use a separate
+    database connection than the calling thread, so they will not
+    respect transactions in the calling thread, or other cases where
+    the calling thread checks out a connection directly using
+    Database#synchronize.  They will also not respect the use of
+    Database#with_server (from the server_block extension) in the
+    calling thread.
+
+  * Dataset methods executed asynchronously should never ignore their
+    return value.  Code such as:
+
+      DB[:table].async.insert(1)
+
+    is probablematic because without storing the return value, you
+    have no way to block until the insert has been completed.
+
+  * The returned object for Dataset methods executed asynchronously is
+    a proxy object (promise).  So you should never do:
+
+      row = DB[:table].async.first
+      # ...
+      if row
+      end
+
+      # or:
+
+      bool = DB[:table].async.get(:boolean_column)
+      # ...
+      if bool
+      end
+
+    because the if branches will always be taken as row and bool will
+    never be nil or false.  If you want to get the underlying value,
+    call itself on the proxy object (or __value if using Ruby <2.2).
+
+    For the same reason, you should not use the proxy objects directly
+    in case expressions or as arguments to Class#===.  Use itself or
+    __value in those cases.
+
+  * Dataset methods executed asynchronously that include blocks have the
+    block executed asynchronously as well, assuming that the method
+    calls the block.  Because these blocks are executed in a separate
+    thread, you cannot use control flow modifiers such as break or
+    return in them.
+
+* An async_thread_pool model plugin has been added.  This requires the
+  async_thread_pool extension has been loaded into the model's Database
+  object, and allows you to call Model.async instead of
+  Model.dataset.async.  It also adds async support to the destroy,
+  with_pk, and with_pk! model dataset methods.
+
+* Model#to_json_data has been added to the json_serializer plugin, for
+  returning a hash of data that can be converted to JSON, instead of
+  a JSON string.
+
+* A :reject_nil option has been added to the nested_attributes method
+  in the nested_attributes plugin.  This will ignore calls to the
+  nested attributes setter method where nil is passed as the setter
+  method argument.
+
+= Other Improvements
+
+* Model#freeze now works in case where model validation modifies the
+  object beyond adding errors.
+
+* Model#freeze in the composition, serialization, and
+  serialization_modification_detection plugins now works in cases
+  where validation would end up loading the composed or
+  serialized values.
+
+* Database#extension now avoids a possible thread safety issue that
+  could result in the extension being loaded into the Database twice.
+
+* The ado adapter now supports overriding the timestamp conversion
+  proc.  Previously, unlike other conversion procs, the timestamp
+  conversion proc was hard coded and could not be overridden.