sequel 5.41.0 → 5.46.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b0886ae2f4e4f4490b56ced6137e2d849cac2458119d6e67d9a756328336ece6
-  data.tar.gz: 9c4946c8ca82b2b1c99ee9065bef0aa81175128564cd7ab0c0405bd4e682b339
+  metadata.gz: 8202d77fff48270013e8d06b75c5ab51933ff9e3fda72f99139211c9cb00de65
+  data.tar.gz: 15393a6189c83eb324e243d81805da38deced274d3f3a1b64bbf3cee54a27fa6
 SHA512:
-  metadata.gz: aa61ea3a0cb3d0e3ab021d27589e10250ed9d9d5a0b4bf314729d55661624161cabffe9c87278761890a900949756e185ce1f263bf742d9b317f2621a1f75c09
-  data.tar.gz: a8253ea1f6e77b592eb40de7b2544b7b34ff8cd02a79e4dfe5bb26b796dd80d49f052e307590af71fb67b292bc9b9c1def8f400eea0977fdb0d85928a6e9f181
+  metadata.gz: 35aa602f835100be3a01bec05ecfb3a0d53555774d1dff520963c254d79c8123328f61e2252c8cb9c69b935f015de7c53f5cbeaec378d425666e7c96bcd0dba7
+  data.tar.gz: b52d0a0e2ea2fe6e388bd8fc694bac86d66f960cba0ed6c952213ba2414395862d3ba734b1763f13883ec7f7983cf69fe75a39a0f8e9406af46e2a2974f7210e

data/CHANGELOG

@@ -1,3 +1,49 @@
+=== 5.46.0 (2021-07-01)
+
+* Add unused_associations plugin, for determining which associations and association methods are not used (jeremyevans)
+
+* Make nil :setter/:adder/:remover/:clearer association options not create related methods (jeremyevans)
+
+=== 5.45.0 (2021-06-01)
+
+* Fix handling of NULL values in boolean columns in the ODBC adapter (jeremyevans) (#1765)
+
+* Add auto_validations_constraint_validations_presence_message plugin for auto_validations/constraint_validations presence message integration (jeremyevans)
+
+* Support Dataset#with :materialized option on SQLite 3.35+ for [NOT] MATERIALIZED (jeremyevans)
+
+* Use ALTER TABLE DROP COLUMN for dropping columns on SQLite 3.35+ (jeremyevans)
+
+=== 5.44.0 (2021-05-01)
+
+* Add concurrent_eager_loading plugin, for eager loading multiple associations concurrently using separate threads (jeremyevans)
+
+* Support :weeks as a interval unit in the date_arithmetic extension (jeremyevans) (#1759)
+
+* Raise an exception if an interval hash with an unsupported key is passed in the date_arithmetic extension (jeremyevans) (#1759)
+
+* Support dropping non-composite unique constraints on SQLite (jeremyevans) (#1755)
+
+=== 5.43.0 (2021-04-01)
+
+* Add column_encryption plugin, for encrypting column values (jeremyevans)
+
+=== 5.42.0 (2021-03-01)
+
+* Make the ado timestamp conversion proc a normal conversion proc that can be overridden similar to other conversion procs (jeremyevans)
+
+* Add :reject_nil option to the nested_attributes method, to ignore calls where nil is passed as the associated object data (jeremyevans)
+
+* Add async_thread_pool plugin for easier async usage with model classes and support for async destroy, with_pk, and with_pk! methods (jeremyevans)
+
+* Add async_thread_pool Database extension for executing queries asynchronously using a thread pool (jeremyevans)
+
+* Fix possible thread safety issue in Database#extension that could allow Module#extended to be called twice with the same Database instance (jeremyevans)
+
+* Support cases where validations make modifications beyond setting errors in Model#freeze (jeremyevans)
+
+* Add Model#to_json_data to the json_serializer plugin, returning a JSON data structure (jeremyevans)
+
 === 5.41.0 (2021-02-01)
 
 * Have explicit :text option for a String column take priority over :size option on PostgreSQL (jeremyevans) (#1750)

data/README.rdoc

@@ -22,10 +22,9 @@ RDoc Documentation :: http://sequel.jeremyevans.net/rdoc
 Source Code :: https://github.com/jeremyevans/sequel
 Bug tracking (GitHub Issues) :: http://github.com/jeremyevans/sequel/issues
 Discussion Forum (sequel-talk Google Group) :: http://groups.google.com/group/sequel-talk
-IRC Channel (#sequel) :: irc://irc.freenode.net/sequel
 
 If you have questions about how to use Sequel, please ask on the
-sequel-talk Google Group or IRC.  Only use the the bug tracker to report
+sequel-talk Google Group.  Only use the the bug tracker to report
 bugs in Sequel, not to ask for help on using Sequel.
 
 To check out the source code:

data/doc/association_basics.rdoc

@@ -826,6 +826,8 @@ you also wanted to handle the Artist#add_album method:
     end)
   end
 
+You can set this to +nil+ to not create a add_<i>association</i> method.
+
 === :remover (\_remove_<i>association</i> method)
 
 Continuing with the same example, here's how you would handle the same case if
@@ -837,6 +839,8 @@ you also wanted to handle the Artist#remove_album method:
     end)
   end
 
+You can set this to +nil+ to not create a remove_<i>association</i> method.
+
 === :clearer (\_remove_all_<i>association</i> method)
 
 Continuing with the same example, here's how you would handle the same case if
@@ -850,6 +854,22 @@ you also wanted to handle the Artist#remove_all_albums method:
     end)
   end
 
+You can set this to +nil+ to not create a remove_all_<i>association</i> method.
+
+=== :no_dataset_method
+
+Setting this to true will not result in the <i>association</i>_dataset method
+not being defined. This can save memory if you only use the <i>association</i>
+method and do not call the <i>association</i>_dataset method directly or
+indirectly.
+
+=== :no_association_method
+
+Setting this to true will not result in the <i>association</i> method
+not being defined. This can save memory if you only use the
+<i>association</i>_dataset method and do not call the <i>association</i> method
+directly or indirectly.
+
 == Association Options
 
 Sequel's associations mostly share the same options.  For ease of understanding,
@@ -1638,9 +1658,8 @@ For +many_to_one+ and +one_to_one+ associations, do not add a setter method.
 For +one_to_many+ and +many_to_many+, do not add the add_<i>association</i>,
 remove_<i>association</i>, or remove_all_<i>association</i> methods.
 
-If the default modification methods would not do what you want, and you
-don't plan on overriding the internal modification methods to do what you
-want, it may be best to set this option to true.
+If you are not using the association modification methods, setting this
+value to true will save memory.
 
 ==== :validate
 

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.

data/doc/release_notes/5.43.0.txt

@@ -0,0 +1,98 @@
+= New Features
+
+* A column_encryption plugin has been added to support encrypting the
+  content of individual columns in a table.
+
+  Column values are encrypted with AES-256-GCM using a per-value
+  cipher key derived from a key provided in the configuration using
+  HMAC-SHA256.
+
+  If you would like to support encryption of columns in more than one
+  model, you should probably load the plugin into the parent class of
+  your models and specify the keys:
+ 
+    Sequel::Model.plugin :column_encryption do |enc|
+      enc.key 0, ENV["SEQUEL_COLUMN_ENCRYPTION_KEY"]
+    end
+ 
+  This specifies a single master encryption key.  Unless you are
+  actively rotating keys, it is best to use a single master key.
+ 
+  In the above call, 0 is the id of the key, and
+  ENV["SEQUEL_COLUMN_ENCRYPTION_KEY"] is the content of the key, which
+  must be a string with exactly 32 bytes. As indicated, this key
+  should not be hardcoded or otherwise committed to the source control
+  repository.
+ 
+  For models that need encrypted columns, you load the plugin again,
+  but specify the columns to encrypt:
+ 
+    ConfidentialModel.plugin :column_encryption do |enc|
+      enc.column :encrypted_column_name
+      enc.column :searchable_column_name, searchable: true
+      enc.column :ci_searchable_column_name, searchable: :case_insensitive
+    end
+ 
+  With this, all three specified columns (encrypted_column_name, 
+  searchable_column_name, and ci_searchable_column_name) will be
+  marked as encrypted columns.  When you run the following code:
+ 
+    ConfidentialModel.create(
+      encrypted_column_name: 'These',
+      searchable_column_name: 'will be',
+      ci_searchable_column_name: 'Encrypted'
+    )
+ 
+  It will save encrypted versions to the database.
+  encrypted_column_name will not be searchable, searchable_column_name
+  will be searchable with an exact match, and
+  ci_searchable_column_name will be searchable with a case insensitive
+  match.
+ 
+  To search searchable encrypted columns, use with_encrypted_value.
+  This example code will return the model instance created in the code
+  example in the previous section:
+ 
+    ConfidentialModel.
+      with_encrypted_value(:searchable_column_name, "will be")
+      with_encrypted_value(:ci_searchable_column_name, "encrypted").
+      first
+
+  To rotate encryption keys, add a new key above the existing key,
+  with a new key ID:
+ 
+    Sequel::Model.plugin :column_encryption do |enc|
+      enc.key 1, ENV["SEQUEL_COLUMN_ENCRYPTION_KEY"]
+      enc.key 0, ENV["SEQUEL_OLD_COLUMN_ENCRYPTION_KEY"]
+    end
+ 
+  Newly encrypted data will then use the new key.  Records encrypted
+  with the older key will still be decrypted correctly.
+ 
+  To force reencryption for existing records that are using the older
+  key, you can use the needing_reencryption dataset method and the
+  reencrypt instance method. For a small number of records, you can
+  probably do:
+ 
+    ConfidentialModel.needing_reencryption.all(&:reencrypt)
+ 
+  With more than a small number of records, you'll want to do this in
+  batches.  It's possible you could use an approach such as:
+ 
+    ds = ConfidentialModel.needing_reencryption.limit(100)
+    true until ds.all(&:reencrypt).empty?
+ 
+  After all values have been reencrypted for all models, and no models
+  use the older encryption key, you can remove it from the
+  configuration:
+ 
+    Sequel::Model.plugin :column_encryption do |enc|
+      enc.key 1, ENV["SEQUEL_COLUMN_ENCRYPTION_KEY"]
+    end
+
+  The column_encryption plugin supports encrypting serialized data,
+  as well as enforcing uniquenss of searchable encrypted columns
+  (in the absence of key rotation).  By design, it does not support
+  compression, mixing encrypted and unencrypted data in the same
+  column, or support arbitrary encryption ciphers.  See the plugin
+  documentation for more details.

data/doc/release_notes/5.44.0.txt

@@ -0,0 +1,32 @@
+= New Features
+
+* A concurrent_eager_loading plugin has been added.  This plugin
+  builds on top of the async_thread_pool Database extension and
+  allows eager loading multiple associations concurrently in
+  separate threads.  With this plugin, you can mark datasets for
+  concurrent eager loading using eager_load_concurrently:
+
+    Album.eager_load_concurrently.eager(:artist, :genre, :tracks).all
+
+  Datasets that are marked for concurrent eager loading will use
+  concurrent eager loading if they are eager loading more than one
+  association.  If you would like to make concurrent eager loading
+  the default, you can load the plugin with the :always option.
+
+  All of the association types that ship with Sequel now support
+  concurrent eager loading when using this plugin. For custom eager
+  loaders using the :eager_loader association option, please see the
+  documentation for the plugin for how to enable custom eager loading
+  for them.
+
+= Other Improvements
+
+* The date_arithmetic extension now handles ActiveSupport::Duration
+  values with weeks, as well as :weeks as a key in a hash value. Weeks
+  are converted into 7 days internally.
+
+* The shared SQLite adapter now emulates the dropping of non-composite
+  unique constraints.  Non-composite unique constraints are now
+  treated similarly to composite unique constraints, in that dropping
+  any unique constraints on a table will drop all unique constraints
+  on that table.

data/doc/release_notes/5.45.0.txt

@@ -0,0 +1,34 @@
+= New Features
+
+* A auto_validations_constraint_validations_presence_message plugin
+  has been added that provides integration for the auto_validations
+  and constraint_validations plugin in the following conditions:
+  
+  * The column has a NOT NULL constraint
+  * The column has a presence constraint validation with both
+    the :message and :allow_nil options used.
+
+  In this case, when saving a nil value in the column, the plugin
+  will make it so the more specific message from the presence
+  constraint validation is used, instead of the generic message
+  from auto_validations.
+
+= Other Improvements
+
+* On SQLite 3.35.0+, Sequel now uses ALTER TABLE DROP COLUMN for
+  dropping columns, instead of emulating the dropped column by
+  recreating the table.
+
+* The Dataset#with :materialized option is now supported on SQLite
+  3.35.0+ for specifying whether common table expressions should be
+  materialized.
+
+* The odbc adapter now correct handles boolean columns with NULL
+  values.  Previously, such values were returned as false instead
+  of nil.
+
+= Backwards Compatibility
+
+* The change to use ALTER TABLE DROP COLUMN on SQLite 3.35.0+ can
+  cause backwards compatibility issues if SQLite 3.35.0+ does
+  not allow dropping the column.

data/doc/release_notes/5.46.0.txt

@@ -0,0 +1,87 @@
+= New Features
+
+* An unused_associations plugin has been added, which allows you to
+  determine which associations and association methods are not used.
+  You can use this to avoid defining the unused associations and
+  association methods, which can save memory.
+
+  This plugin is supported on Ruby 2.5+, and uses method coverage to
+  determine if the plugin's methods are called.  Because Sequel::Model
+  adds association methods to an anonymous module included in the
+  class, directly using the method coverage data to determine which
+  associations are used is challenging.
+
+  This plugin is mostly designed for reporting.  You can have a
+  test suite that runs with method coverage enabled, and use the
+  coverage information to get data on unused associations:
+
+    # Calls Coverage.result
+    cov_data = Sequel::Model.update_associations_coverage
+    unused_associations_data = Sequel::Model.update_unused_associations_data(coverage_data: cov_data)
+    Sequel::Model.unused_associations(unused_associations_data: unused_associations_data)
+    # => [["Class1", "assoc1"], ...]
+
+  unused_associations returns an array of two element arrays, where
+  the first element is the class name and the second element is the
+  association name.  The returned values will be associations where
+  all of the association methods are not used.
+
+  In addition to determining which associations are not used, you can
+  also use this to determine if you are defining association methods
+  that are not used:
+
+    Sequel::Model.unused_association_options(unused_associations_data: unused_associations_data)
+    # => [["Class2", "assoc2", {:read_only=>true}], ...]
+
+  unused_association_options is similar to unused_associations, but
+  returns an array of three element arrays, where the third element
+  is a hash of association options that should be used to avoid
+  defining the unused association methods.  It's common in Sequel to
+  define associations and only use them for reading data and not for
+  modifications, and you can use this to easily see which associations
+  are only used for reading data.
+
+  As the determination of whether associations are used is based on
+  method coverage, this will report as unused any associations that are
+  used but where the association methods are not called.  These cases
+  are rare, but can happen if you have libraries that use the
+  association reflection metadata without calling the association
+  methods, or use the association only in combination with another
+  plugin such as dataset_associations.  You can set the :is_used
+  association option to explicitly mark an association as used, and
+  have this plugin avoid reporting it as unused.
+
+  In addition to just reporting on unused associations, you can also
+  directly use the unused associations metadata to automatically avoid
+  defining unused associations or unused associations methods.  You
+  can set a :file option when loading the plugin:
+
+    Sequel::Model.plugin :unused_associations, file: 'unused_associations.json'
+
+  Then run the method coverage testing.  This will save the unused
+  associations metadata to the file.  Then you can use this metadata
+  automatically by also setting the :modify_associations option:
+
+    Sequel::Model.plugin :unused_associations, file: 'unused_associations.json',
+      modify_associations: true
+
+  With the :modify_associations option, unused associations are
+  skipped instead of being defined, and the options returned by
+  unused_association_options are automatically used.  Note that using
+  the :modify_associations option is risky unless you have complete 
+  coverage and do not have cases where the associations are used
+  without calling methods.
+
+  It is common to have multiple test suites where you need to combine
+  coverage.  The plugin supports this by using a :coverage_file option:
+
+    Sequel::Model.plugin :unused_associations, coverage_file: 'unused_associations_coverage.json'
+
+  In this case, you would run update_associations_coverage after each
+  test suite, and update_unused_associations_data only after all test
+  suites have been run.
+
+* Passing nil as the value of the :setter, :adder, :remover, or
+  :clearer association options will cause the related method to not be
+  defined, instead of using the default value.  This allows you to
+  only define the methods you will actually be using.