sequel 5.37.0 → 5.42.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a8314ec290f56d764f7d072c3982407c7478c4f762248cee2243b74dc82a6a31
-  data.tar.gz: 4df47669ee1ff9f2a93ad6aaca195f168a7fa61572fe77347af9959eea6e025a
+  metadata.gz: 41e987d42df8d1b3ab41dd6555b5e338b94ba0e2fcd11fa3db7f9b955920d533
+  data.tar.gz: fdcaed20caa20bbaffe5854cbcd6836787e92a2bbadb89373337602926d476ca
 SHA512:
-  metadata.gz: 6b1d811a54e04b79b92c96a8a93f6d1b714dc15451790f4db6a8e0f7f133be1d7350fa46a30448445089aa5cada2c05270bc6382d36e89a6e2d1a9efd5ceec2c
-  data.tar.gz: dce7a9c8cda4f7498de3af2fe999e8ed3b1566d7022b1274352ce397eca96c8b234dfe13549ed0e613e24effa3519b46cd3c037b7abe62ce84367396ce7f71c7
+  metadata.gz: c9a3927fe546ee7f91497e5bd50e9fa9241dd46aa7d3b3c331d10f8ac369eedd204a488207c509e909d9eb5d7deeeb13ab20888568f7e91f53fba526323df566
+  data.tar.gz: a9108c8ce0d78d93c94f0a947171687022dd20ee1305633533340f1cb1a71d012248f9a9bb72eb7af28cc258240ec2e8f090683d1ad7a68c33f69d261c684ea0

data/CHANGELOG

@@ -1,3 +1,65 @@
+=== 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)
+
+* Support a :skip_invalid option in auto_validations plugin for not adding errors to a column that already has an error (jeremyevans)
+
+* Support a :skip_invalid option in validation_helpers for not adding an error to a column that already has an error (jeremyevans)
+
+* Support :adder, :remover, and :clearer association options that use keyword arguments in Ruby 2.7+ (jeremyevans)
+
+* Make pg_interval use the same number of seconds per year and per month as ActiveSupport::Duration when using ActiveSupport 5.1+ (jeremyevans)
+
+=== 5.40.0 (2021-01-01)
+
+* Support UPDATE FROM syntax in SQLite 3.33.0+ (jeremyevans)
+
+* Have pg_interval extension work with ActiveSupport 6.1 (jeremyevans)
+
+* Have date_arithmetic extension work with ActiveSupport 6.1 (jeremyevans)
+
+* Avoid method redefinition warnings in verbose warning mode (jeremyevans)
+
+=== 5.39.0 (2020-12-01)
+
+* Support :clustered option for primary key and unique constraints on Microsoft SQL Server (jeremyevans)
+
+* Do not modify the size of binary columns when using set_column_allow_null on Microsoft SQL Server (jeremyevans) (#1736)
+
+* Add a fork safety guide with more detail on how to use Sequel with libraries that fork (janko) (#1733)
+
+* Make the roots_dataset method in the tree plugin work with queries using joins (jeremyevans) (#1731)
+
+* Make Database#tables return partitioned tables on PostgreSQL 10+ (epoberezhny) (#1729, #1730)
+
+=== 5.38.0 (2020-11-01)
+
+* Do not add new Database instances to Sequel::DATABASES if the test connection fails (jeremyevans) (#1727)
+
+* Support the newer com.mysql.cj.jdbc.Driver in the jdbc/mysql adapter (jeremyevans)
+
+* Do not swallow disconnect errors in Database#create_or_replace_view or Database#create_table* on Oracle (jeremyevans)
+
+* Only rescue non-disconnect Sequel::DatabaseErrors in Postgres::Database#server_version (jeremyevans) (#1724)
+
+* Make the single_table_inheritance and prepared_statements plugins work if loaded into the same class (jeremyevans) (#1721)
+
 === 5.37.0 (2020-10-01)
 
 * Recognize more unsigned decimal/float types in the schema dumper (akimd, jeremyevans) (#1720)

data/MIT-LICENSE

@@ -1,5 +1,5 @@
 Copyright (c) 2007-2008 Sharon Rosner
-Copyright (c) 2008-2020 Jeremy Evans
+Copyright (c) 2008-2021 Jeremy Evans
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to

data/README.rdoc

@@ -883,7 +883,7 @@ raise an error by default:
 == Sequel Release Policy
 
 New major versions of Sequel do not have a defined release policy, but historically have
-occurred once ever few years.
+occurred once every few years.
 
 New minor versions of Sequel are released around once a month near the start of the month.
 

data/doc/cheat_sheet.rdoc

@@ -95,18 +95,18 @@ Without a filename argument, the sqlite adapter will setup a new sqlite database
 
 === AND/OR/NOT
 
-  DB[:items].where{(x > 5) & (y > 10)}.sql 
+  DB[:items].where{(x > 5) & (y > 10)} 
   # SELECT * FROM items WHERE ((x > 5) AND (y > 10))
 
-  DB[:items].where(Sequel.or(x: 1, y: 2) & Sequel.~(z: 3)).sql 
+  DB[:items].where(Sequel.or(x: 1, y: 2) & Sequel.~(z: 3)) 
   # SELECT * FROM items WHERE (((x = 1) OR (y = 2)) AND (z != 3))
 
 === Mathematical operators
 
-  DB[:items].where{x + y > z}.sql 
+  DB[:items].where{x + y > z} 
   # SELECT * FROM items WHERE ((x + y) > z)
 
-  DB[:items].where{price - 100 < avg(price)}.sql 
+  DB[:items].where{price - 100 < avg(price)} 
   # SELECT * FROM items WHERE ((price - 100) < avg(price))
 
 === Raw SQL Fragments
@@ -130,7 +130,7 @@ Without a filename argument, the sqlite adapter will setup a new sqlite database
 
 == Joins
 
-  DB[:items].left_outer_join(:categories, id: :category_id).sql 
+  DB[:items].left_outer_join(:categories, id: :category_id) 
   # SELECT * FROM items
   # LEFT OUTER JOIN categories ON categories.id = items.category_id
 

data/doc/code_order.rdoc

@@ -100,15 +100,3 @@ and freezing them can easily be achieved through the plugin:
   # ... 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
-a feature that loads your Sequel code before forking connections (code
-preloading), then you must disconnect your database connections before
-forking.  If you don't do this, you can end up with child processes
-sharing database connections and all sorts of weird behavior.  Sequel
-will automatically reconnect on an as needed basis in the child
-processes, so you only need to do the following in the parent process:
-
-  DB.disconnect

data/doc/fork_safety.rdoc

@@ -0,0 +1,84 @@
+= Fork Safety
+
+If you are forking or using a library that forks after you have created a
+Sequel::Database instance, then you must disconnect database connections before forking. If you
+don't do this, you can end up with child processes sharing database connections
+and all sorts of weird behavior, including crashes.  Sequel will automatically create new
+connections on an as needed basis in the child processes, so you only need to do the following in
+the parent process:
+
+  DB.disconnect
+
+Or if you have connections to multiple databases:
+
+  Sequel::DATABASES.each(&:disconnect)
+
+== Puma
+
+When using the Puma web server in clustered mode (which is the default behavior in Puma 5+ when
+using multiple processes), you should disconnect inside the +before_fork+ hook in your
+Puma config:
+
+  before_fork do
+    Sequel::DATABASES.each(&:disconnect)
+  end
+
+== Unicorn
+
+When using the Unicorn web server and preloading the application (+preload_app true+ in the Unicorn
+config), you should disconnect inside the +before_fork+ hook in the Unicorn config:
+
+  before_fork do
+    Sequel::DATABASES.each(&:disconnect)
+  end
+
+== Passenger
+
+In Passenger web server, you should disconnect inside the
++starting_worker_process+ event hook:
+
+  if defined?(PhusionPassenger)
+    PhusionPassenger.on_event(:starting_worker_process) do |forked|
+      Sequel::DATABASES.each(&:disconnect) if forked
+    end
+  end
+
+Note that this disconnects after forking instead of before forking.  Passenger does not
+offer a before fork hook.
+
+== Spring
+
+In Spring application preloader, you should disconnect inside the +after_fork+ hook:
+
+  if defined?(Spring)
+    Spring.after_fork do
+      Sequel::DATABASES.each(&:disconnect)
+    end
+  end
+
+As the method indicates, this disconnects after forking instead of before forking.
+Spring does not offer a before fork hook.
+
+== Resque
+
+In Resque, you should disconnect inside the +before_fork+ hook:
+
+  Resque.before_fork do |job|
+    Sequel::DATABASES.each(&:disconnect)
+  end
+
+== Parallel
+
+If you're using the Parallel gem with processes, you should disconnect before
+calling it:
+
+  Sequel::DATABASES.each(&:disconnect)
+  Parallel.map(['a','b','c'], in_processes: 3) { |one_letter| }
+
+== Other Libraries Calling fork
+
+For any other library that calls fork, you should disconnect before calling
+a method that forks:
+
+  Sequel::DATABASES.each(&:disconnect)
+  SomeLibrary.method_that_forks

data/doc/opening_databases.rdoc

@@ -208,7 +208,7 @@ Example connection strings:
 
   jdbc:sqlite::memory:
   jdbc:postgresql://localhost/database?user=username
-  jdbc:mysql://localhost/test?user=root&password=root
+  jdbc:mysql://localhost/test?user=root&password=root&serverTimezone=UTC
   jdbc:h2:mem:
   jdbc:hsqldb:mem:mymemdb
   jdbc:derby:memory:myDb;create=true
@@ -240,6 +240,10 @@ The following additional options are supported:
 There are a few issues with specific jdbc driver gems:
 
 jdbc-h2 :: jdbc-h2 versions greater than 1.3.175 have issues with ORDER BY not working correctly in some cases.
+jdbc-mysql :: Depending on the configuration of the MySQL server, jdbc-mysql versions greater 8 may complain
+              about the server time zone being unrecognized.  You can either use an older jdbc-mysql version,
+              or you can specify the +serverTimezone+ option in the connection string, as shown in the example
+              jdbc:mysql connection string above.
 
 === mysql 
 

data/doc/postgresql.rdoc

@@ -213,7 +213,7 @@ other tables.  Support may be added in the future.
 === Creating Unlogged Tables
 
 PostgreSQL allows users to create unlogged tables, which are faster but not crash safe.  Sequel
-allows you do create an unlogged table by specifying the <tt>unlogged: true</tt> option to +create_table+:
+allows you to create an unlogged table by specifying the <tt>unlogged: true</tt> option to +create_table+:
 
   DB.create_table(:table, unlogged: true){Integer :i}
   # CREATE UNLOGGED TABLE "table" ("i" integer)

data/doc/querying.rdoc

@@ -746,7 +746,7 @@ shortcuts for all common (and most uncommon) join types. For example
 
   Album.join(:artists, id: :artist_id)
   # SELECT * FROM albums
-  # INNER JOIN artists ON (artists.id = albums.artist_id))))
+  # INNER JOIN artists ON (artists.id = albums.artist_id)
 
 And +left_join+ does a LEFT JOIN:
 
@@ -870,14 +870,14 @@ In this case, you don't even need to specify any conditions.
 ==== Join Blocks
 
 You can provide a block to any of the join methods that accept
-conditions.  This block should accept 3 arguments, the table alias
+conditions.  This block should accept 3 arguments: the table alias
 for the table currently being joined, the table alias for the last
 table joined (or first table), and an array of previous
 <tt>Sequel::SQL::JoinClause</tt>s.
 
 This allows you to qualify columns similar to how the implicit
 qualification works, without worrying about the specific aliases
-being used.  For example, lets say you wanted to join the albums
+being used.  For example, let's say you wanted to join the albums
 and artists tables, but only want albums where the artist's name
 comes before the album's name.
 

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.