sequel 5.31.0 → 5.36.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f7419480f1c01043fb35c490c25cfbbcfaa9b5694ad41462f7af1c5e5e57bdf5
-  data.tar.gz: 7fe799521a27993775f197f15cc38b780c04a3d8d4a9a8ef931da1bea2308779
+  metadata.gz: b3ea26531aa8ce58a1d98b14e4df51dc2c364285d915486baf3647347c482c96
+  data.tar.gz: f4588646c72d99490d19e637eede86fe9cd3421c8c2c861802c6e9bf4c3b5425
 SHA512:
-  metadata.gz: c3c37683caeb5390eaf614d481be330af8685a07250f4464487d45f0cc0758b94afc28c7008f6ba62f2945f92caf7dc83f2e43907d534e502d16c62e8b0d1c4d
-  data.tar.gz: 49eb980c909fb2490b7e0ec808c0594e84f80593baed607917cd40ed99abab69fc42daf8e7fc5d4691785a0681fa1689c9e1c5130813c0d89cb5e5d638e60cd8
+  metadata.gz: aa483b284775682fb6b33b56bcccf33bc32a22e0161964a5e8679d461dd6ac3e5e4d4575a10887e71a730d85d8b04194fb739ee122093ae797df18a4e70534c9
+  data.tar.gz: fcc040944c40bc0be1faf2b4eafc3e1d34ea8a409c6ef45e26ae7f25f6d38c4f7b66445902b71b05e55eaccb37c1c1ee47c29d8a5135dd45b95a8b5d50ffe0dd

data/CHANGELOG

@@ -1,3 +1,93 @@
+=== 5.36.0 (2020-09-01)
+
+* Handle passing keyword arguments through class methods defined via Plugins.def_dataset_method on Ruby 2.7+ (jeremyevans)
+
+* Handle passing keyword arguments through when loading plugins on Ruby 2.7+ (jeremyevans)
+
+* Handle passing keyword arguments through migrations when defining custom Database methods that accept keywords on Ruby 2.7+ (jeremyevans)
+
+* Handle passing keyword arguments through Dataset#query when using the query extension on Ruby 2.7+ (jeremyevans)
+
+* Handle passing keyword arguments through the association proxy when using the association_proxies plugin on Ruby 2.7+ (jeremyevans)
+
+* Handle passing keyword arguments through the class method to a method defined in dataset_module on Ruby 2.7+ (adam12) (#1713)
+
+* Stream result sets in the odbc adapter for better performance and lower memory usage (sparrovv) (#1711)
+
+* Add Postgres::JSONBOp#set_lax and #path_*_tz methods to the pg_json_ops extension for new jsonb functions added in PostgreSQL 13 (jeremyevans)
+
+* Add Dataset#with_ties on PostgreSQL 13+ and Microsoft SQL Server to include rows with same order as final row (jeremyevans)
+
+* Add a :current_schema option to Database#view_exists? (only defined on Oracle) to look in the current schema instead of non-system schemas (jeremyevans) (#1710)
+
+* Recognize another disconnect error in the mysql and mysql2 adapters (jeremyevans) (#1706)
+
+=== 5.35.0 (2020-08-01)
+
+* Recognize another disconnect error in the oracle adapter (sterlzbd) (#1705)
+
+* Consider all associations with :dataset options as instance-specific associations (jeremyevans)
+
+* Make Model.finalize_associations not break with instance-specific associations (jeremyevans)
+
+* Make association placeholder loader consider block if instance_specific: false association option is used (jeremyevans)
+
+* Copy composite unique constraints when emulating alter table operations on SQLite (jeremyevans) (#1704)
+
+* Add instance_specific_default plugin for setting default association :instance_specific value, or warning/raising for cases where it is not specified (jeremyevans)
+
+* Make Model.plugin issue deprecation warning if loading plugin with arguments and block if plugin does not accept arguments/block (jeremyevans)
+
+* Make validation_class_methods consider all :if, :allow_missing, :allow_nil, and :allow_blank settings, instead of just the first (jeremyevans)
+
+* Include hash entries with nil keys in Dataset#to_dot output in to_dot extension (jeremyevans)
+
+* Remove unneeded conditionals from plugins and extensions (jeremyevans)
+
+* Fix exception class in run_transaction_hooks extension if calling run_after_{commit,rollback}_hooks outside of a transaction (jeremyevans)
+
+=== 5.34.0 (2020-07-01)
+
+* Make eager_graph work correctly if called with no associations (jeremyevans)
+
+* Make :ruby eager limit strategy handle cases where there is no limit or offset (jeremyevans)
+
+* Do not keep a reference to a Sequel::Database instance that raises an exception during initialization (jeremyevans)
+
+* Make Database#pool.all_connections not yield for a single connection pool in disconnected state (jeremyevans)
+
+* Raise an exception if trying to disconnect a server that doesn't exist in the sharded connection pools (jeremyevans)
+
+* Support :refresh option when calling *_pks getter method in the association_pks plugin (jeremyevans)
+
+* Support caching of repeated calls to *_pks getter method in the association_pks plugin using :cache_pks association option (jeremyevans)
+
+* Add *_pks_dataset methods for one_to_many and many_to_many associations when using the association_pks plugin (jeremyevans)
+
+=== 5.33.0 (2020-06-01)
+
+* Support custom join types on a per-association basis when using eager_graph/association_join (jeremyevans)
+
+* Support primary_key with type: :smallserial on PostgreSQL (j-a-m-l) (#1698)
+
+* Add Database#current_timestamp_utc accessor on SQLite to keep CURRENT_* in UTC instead of converting to localtime (jeremyevans)
+
+=== 5.32.0 (2020-05-01)
+
+* Allow Database#create_table? work with :partition_of option on PostgreSQL (jeremyevans) (#1690)
+
+* Add fiber_concurrency extension, for using Fiber.current instead of Thread.current for checking out connections (jeremyevans)
+
+* Move most Sequel singleton methods into a module that extends Sequel for easier overriding (jeremyevans)
+
+* Fix method visibility issues in model, plugin, extension, and adapter code (jeremyevans)
+
+* Avoid defining conversion procs for PostgreSQL inet/cidr types in pg_inet extension when using sequel_pg 1.13.0+ (jeremyevans)
+
+* Add run_transaction_hooks Database extension, allowing for running the transaction hooks before commit/rollback, for use with transactional testing (jeremyevans)
+
+* Recognize timestamp(N) with time zone type (isc) (#1684)
+
 === 5.31.0 (2020-04-01)
 
 * Fix alter_table drop_constraint :primary_key option on SQLite for non-integer primary keys (jeremyevans)

data/README.rdoc

@@ -172,7 +172,7 @@ Datasets are the primary way records are retrieved and manipulated.  They are ge
   posts = DB.from(:posts)
   posts = DB[:posts] # same
 
-Datasets will only fetch records when you tell them to. They can be manipulated to filter records, change ordering, join tables, etc..  Datasets are always frozen, and they safe to use by multiple threads concurrently.
+Datasets will only fetch records when you tell them to. They can be manipulated to filter records, change ordering, join tables, etc.  Datasets are always frozen, and they are safe to use by multiple threads concurrently.
 
 === Retrieving Records
 

data/doc/advanced_associations.rdoc

@@ -731,7 +731,7 @@ associations:
     one_to_one :tracks, key: [:disc_number, :number, :album_id], primary_key: [:disc_number, :number, :album_id]
   end
 
-=== Tree - All Ancestors and Descendents
+=== Tree - All Ancestors and Descendants
 
 Let's say you want to store a tree relationship in your database, it's pretty
 simple:
@@ -749,7 +749,7 @@ node.children.  You can even eager load the relationship up to a certain depth:
   # Load parents and grandparents for a group of nodes
   Node.where{id < 10}.eager(parent: :parent).all
 
-What if you want to get all ancestors up to the root node, or all descendents,
+What if you want to get all ancestors up to the root node, or all descendants,
 without knowing the depth of the tree?
 
   class Node < Sequel::Model
@@ -770,7 +770,7 @@ without knowing the depth of the tree?
         id_map = {}
         # Create an map of parent_ids to nodes that have that parent id
         non_root_nodes.each{|n| (id_map[n.parent_id] ||= []) << n}
-        # Doesn't cause an infinte loop, because when only the root node
+        # Doesn't cause an infinite loop, because when only the root node
         # is left, this is not called.
         Node.where(id: id_map.keys).eager(:ancestors).all do |node|
           # Populate the parent association for each node
@@ -879,4 +879,4 @@ associated tickets.
   end
 
 Note that it is often better to use a sum cache instead of this approach.  You can implement
-a sum cache using +after_create+, +after_update+, and +after_delete+ hooks, or preferrably using a database trigger.
+a sum cache using +after_create+, +after_update+, and +after_delete+ hooks, or preferably using a database trigger.

data/doc/association_basics.rdoc

@@ -113,7 +113,7 @@ many rows in the current table, by using a join table to associate the two table
 The one_through_one association can be thought of as a subset of the many_to_many
 association, but where there can only be 0 or 1 records in the associated table.
 This is useful if there is a unique constraint on the foreign key in the join table
-that refrences the current table.  It's also useful if you want to impose an order
+that references the current table.  It's also useful if you want to impose an order
 on the association and just want the first record returned.  The one_through_one
 association is so named because it sets up a one-to-one association through a
 single join table.
@@ -781,7 +781,7 @@ Sequel is designed to be very flexible.  If the default behavior of the
 association modification methods isn't what you desire, you can override
 the methods in your classes.  However, you should be aware that for each
 of the association modification methods described, there is a private
-method that is preceeded by an underscore that does the actual
+method that is preceded by an underscore that does the actual
 modification.  The public method without the underscore handles caching
 and callbacks, and shouldn't be overridden by the user.
 
@@ -1069,7 +1069,7 @@ option of the first association, it doesn't attempt to merge them.
 In addition to the options hash, the :clone option will copy a block argument
 from the existing situation.  If you want a cloned association to not have the
 same block as the association you are cloning from, specify the block: nil option
-in additon to the :clone option.
+in addition to the :clone option.
 
 ==== :dataset
 
@@ -1676,11 +1676,16 @@ instances.
 ==== :instance_specific
 
 This allows you to override the setting of whether the dataset contains instance
-specific code.  For example, if you are passing a block to the association,
+specific code.  If you are passing a block to the association,
 Sequel sets this to true by default, which disables some optimizations that
 would be invalid if the association is instance specific.  If you know that the
 block does not contain instance specific code, you can set this to false to
-reenable the optimizations.
+reenable the optimizations.  Instance specific code is mostly commonly calling
+model instance methods inside an association block, but also
+includes cases where the association block can return different values based
+on the runtime environment, such as calls to <tt>Time.now</tt> in the block.
+Associations that use the :dataset option are always considered instance specific,
+even if explicitly specified otherwise.
 
 ==== :cartesian_product_number 
 

data/doc/code_order.rdoc

@@ -7,7 +7,7 @@ this guide will be specific about which are strictly necessary.
 
 == Require Sequel
 
-This is sort of a no brainer, but you need to require the library
+This is sort of a no-brainer, but you need to require the library
 first.  This is a strict requirement, none of the other code can
 be executed unless the library has been required first. Example:
 
@@ -70,7 +70,7 @@ copied into the subclass when model subclasses are created.  Example:
 == Load Model Classes
 
 After you have established a database connection, and configured your
-global model configration and global plugins, you can load your model
+global model configuration and global plugins, you can load your model
 classes.  It's recommended to have a separate file for each model class,
 unless the model classes are very simple.  Example:
 
@@ -91,6 +91,16 @@ 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:
+
+  # Register the plugin before setting up the models
+  Sequel::Model.plugin :subclasses
+  # ... setup models
+  # Now finalize associations & freeze models by calling the plugin:
+  Sequel::Model.freeze_descendents
+
 == Disconnect If Using Forking Webserver with Code Preloading
 
 If you are using a forking webserver such as unicorn or passenger, with

data/doc/dataset_filtering.rdoc

@@ -36,8 +36,8 @@ Ranges (both inclusive and exclusive) can also be used:
 
 If you need to select multiple items from a dataset, you can supply an array:
 
-	items.where(id: [1, 38, 47, 99]).sql
-	# "SELECT * FROM items WHERE (id IN (1, 38, 47, 99))"
+  items.where(id: [1, 38, 47, 99]).sql
+  # "SELECT * FROM items WHERE (id IN (1, 38, 47, 99))"
 
 == Filtering using expressions
 

data/doc/model_dataset_method_design.rdoc

@@ -4,7 +4,7 @@ How you design your model dataset methods can significantly affect the flexibili
 
 == Flexibility: Use Single Method Per Task
 
-In general, it is recommended that you have a single method per task for maximum flexibilty.  For example, let's say you need to retrieve all albums released in a given year, ordered by number of units sold descending, and only care about the id, name and number of units sold.  One way to do this is in your application code (outside the model), you can
+In general, it is recommended that you have a single method per task for maximum flexibility.  For example, let's say you need to retrieve all albums released in a given year, ordered by number of units sold descending, and only care about the id, name and number of units sold.  One way to do this is in your application code (outside the model), you can
 call the dataset methods directly:
 
   Album.

data/doc/model_plugins.rdoc

@@ -212,7 +212,7 @@ In general you should only require plugin arguments if you absolutely must have
 
 == Handling Subclasses
 
-Sequel::Model uses a copy-on-subclassing approach to model state.  So instead of model subclasses asking their parent class for a value if they don't have it defined, the value is automatically copied from the parent class to the subclass when the subclass is created.  While you can do this by overriding the inherited class method, there is a available shortcut that handles most cases:
+Sequel::Model uses a copy-on-subclassing approach to model state.  So instead of having a model subclass ask its superclass for a value if the subclass don't have the value defined, the value should be copied from the parent class to the subclass when the subclass is created.  While this can be implemented by overriding the +inherited+ class method, there is an available shortcut that handles most cases:
 
   module Sequel::Plugins::Foo
     module ClassMethods

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.