sequel 5.81.0 → 5.82.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a23afa1510b7bd1ba6918319eedce156450672520ab4798e6de56461a59660e1
-  data.tar.gz: bb6bbfbf0f1f82fe117fa8c725e9cf4fde49644a74b463ab8682018744a8a1de
+  metadata.gz: f09a139a164322e0a0e52e9a58c79b2f463972363509c41bf50e7082c1f542b7
+  data.tar.gz: e7222b81a79111b9853565160f81cb18c72b341f18bec839046c9b49a4b199ea
 SHA512:
-  metadata.gz: 9e26620f8f1df2715205e9019c2012ec2e9f392d14ed427d66c76f488bccc3e5d3f27e4d626a47d54903d611695db0487f987d99191602024a1864d6c10f7bde
-  data.tar.gz: cd070d8c35960949039d226b5eaf8c90ebec8d0cef3f09b5dae533551bb35170ca6e2503d88f1b1512110b6617ff9c03d9cb2afb62395c4d953314aa5a5ca87c
+  metadata.gz: d9f16395ad855ccbc4494bd2e1436b6b78f15ddbfd1c9b80d356040d99415a46a352f50042b2fc9ab23d29b65567dafec2fceb35c709498159b00a1402991ee6
+  data.tar.gz: a5693c2f3c3791c0216a5af9e933edaa41b0eeb030a3523e52a6951c666e720d0b12ec48ae3f46777ce617b27857f6519d7ce98ec1768a0c8226c4b494e501c1

data/CHANGELOG

@@ -1,3 +1,17 @@
+=== 5.82.0 (2024-07-01)
+
+* Limit tactically eager loading to objects that have the same association reflection (jeremyevans) (#2181)
+
+* Fix race condition in threaded/sharded_threaded connection pools that could cause stalls (jeremyevans)
+
+* Emulate dropping a unique column or a column that is part of an index on SQLite 3.35.0+ (jeremyevans) (#2176)
+
+* Support MERGE RETURNING on PostgreSQL 17+ (jeremyevans)
+
+* Remove use of logger library in bin/sequel (jeremyevans)
+
+* Support :connect_opts_proc Database option for late binding options (jeremyevans) (#2164)
+
 === 5.81.0 (2024-06-01)
 
 * Fix ignored block warnings in a couple plugin apply methods on Ruby 3.4 (jeremyevans)

data/bin/sequel

@@ -18,6 +18,21 @@ load_dirs = []
 exclusive_options = []
 loggers = []
 
+logger_class = Class.new do
+  def initialize(device)
+    @device = device
+  end
+
+  def debug(msg)
+  end
+
+  [:info, :warn, :error].each do |meth|
+    define_method(meth) do |msg|
+      @device.puts("#{Time.now.strftime('%Y-%m-%d %T')} #{meth.to_s.upcase}: #{msg}")
+    end
+  end
+end
+
 options = OptionParser.new do |opts|
   opts.banner = "Sequel: The Database Toolkit for Ruby"
   opts.define_head "Usage: sequel [options] <uri|path> [file]"
@@ -61,8 +76,7 @@ options = OptionParser.new do |opts|
   end
   
   opts.on("-E", "--echo", "echo SQL statements") do
-    require 'logger'
-    loggers << Logger.new($stdout)
+    loggers << logger_class.new($stdout)
   end
   
   opts.on("-I", "--include dir", "specify $LOAD_PATH directory") do |v|
@@ -70,8 +84,7 @@ options = OptionParser.new do |opts|
   end
 
   opts.on("-l", "--log logfile", "log SQL statements to log file") do |v|
-    require 'logger'
-    loggers << Logger.new(v)
+    loggers << logger_class.new(File.open(v, 'a'))
   end
   
   opts.on("-L", "--load-dir DIR", "loads all *.rb under specifed directory") do |v|

data/doc/opening_databases.rdoc

@@ -79,6 +79,9 @@ These options are shared by all adapters unless otherwise noted.
                or string with extensions separated by columns.  These extensions are loaded after
                connections are made by the :preconnect option.
 :cache_schema :: Whether schema should be cached for this database (true by default)
+:connect_opts_proc :: Callable object for modifying options hash used when connecting, designed for
+                      cases where the option values (e.g. password) are automatically rotated on
+                      a regular basis without involvement from the application using Sequel.
 :default_string_column_size :: The default size for string columns (255 by default)
 :host :: The hostname of the database server to which to connect
 :keep_reference :: Whether to keep a reference to the database in Sequel::DATABASES (true by default)

data/doc/release_notes/5.82.0.txt

@@ -0,0 +1,61 @@
+= New Features
+
+* MERGE RETURNING is now supported when using PostgreSQL 17+. For
+  datasets supporting RETURNING, calling merge with a block
+  will yield each returned row:
+
+    DB[:table1].
+      returning.
+      merge_using(:table2, column1: :column2).
+      merge_insert(column3: :column4).
+      merge do |row|
+        # ...
+      end
+    # MERGE INTO "table1" USING "table2"
+    # ON ("column1" = "column2")
+    # WHEN NOT MATCHED THEN
+    # INSERT ("column3") VALUES ("column3")
+    # RETURNING *
+
+* A :connect_opts_proc Database option is now supported, to allow
+  support for late-binding Database options.  If provided, this
+  should be a callable object that is called with the options
+  used for connecting, and can modify the options.  This makes
+  it simple to support authentication schemes that rotate
+  passwords automatically without user involvement:
+
+    Sequel.connect('postgres://user@host/database',
+      connect_opts_proc: lambda do |opts|
+        opts[:password] = SomeAuthLibrary.get_current_password(opts[:user])
+      end)
+
+  Note that the jdbc adapter relies on URIs and not option hashes,
+  so when using the jdbc adapter with this feature, you'll generally
+  need to set the :uri option.
+
+= Other Improvements
+
+* A race condition in the threaded connection pools that could result
+  in a delay or timeout error in checking out connections in low-traffic
+  environments has been fixed.
+
+* Sequel now supports dropping a unique column or a column that is
+  part of an index on SQLite 3.35.0+, with the same emulation approach
+  it uses in earlier SQLite versions.
+
+* The tactical_eager_loading plugin now handles cases where inheritance
+  is used and the objects used include associations with the same name
+  but different definitions.  Sequel will now only eager load the
+  association for objects that use the same association definition as
+  the receiver.
+
+= Backwards Compatibility
+
+* bin/sequel no longer requires logger if passed the -E or -l options.
+  Instead, it uses a simple implementation that supports only
+  debug/warn/info/error methods.  If you are using bin/sequel and
+  depending on the log format produced by the logger library, or
+  calling methods on the logger object other than
+  debug/warn/info/error, you'll need to update your code.  This change
+  was made because logger is moving out of stdlib in a future Ruby
+  version.

data/doc/testing.rdoc

@@ -47,6 +47,20 @@ These run each test in its own transaction, the recommended way to test.
     end
   end
 
+== Transactional testing with multiple threads
+
+Some tests may require executing code across multiple threads. The most common example are browser tests with Capybara, where the web server is running in a separate thread. For transactional tests to work in this case, the main thread needs to allow other threads to use its database connection while the transaction is in progress. This can be achieved with the temporarily_release_connection extension:
+
+  DB.extension :temporarily_release_connection
+  DB.transaction(rollback: :always, auto_savepoint: true) do |conn|
+    DB.temporarily_release_connection(conn) do
+      # Other threads can operate on connection safely inside the transaction
+      yield
+    end
+  end
+
+This requires maximum connection pool size to be 1, so make sure to set the Database +:max_connections+ option to 1 in tests.
+
 == Transactional testing with multiple databases
 
 You can use the Sequel.transaction method to run a transaction on multiple databases, rolling all of them back.  Instead of:

data/lib/sequel/adapters/shared/postgres.rb

@@ -2058,6 +2058,16 @@ module Sequel
         nil
       end
 
+      # Support MERGE RETURNING on PostgreSQL 17+.
+      def merge(&block)
+        sql = merge_sql
+        if uses_returning?(:merge)
+          returning_fetch_rows(sql, &block)
+        else
+          execute_ddl(sql)
+        end
+      end
+
       # Return a dataset with a WHEN MATCHED THEN DO NOTHING clause added to the
       # MERGE statement.  If a block is passed, treat it as a virtual row and
       # use it as additional conditions for the match.
@@ -2087,7 +2097,7 @@ module Sequel
       # Support OVERRIDING USER|SYSTEM VALUE for MERGE INSERT.
       def merge_insert(*values, &block)
         h = {:type=>:insert, :values=>values}
-        if override = @opts[:override]
+        if @opts[:override]
           h[:override] = insert_override_sql(String.new)
         end
         _merge_when(h, &block)
@@ -2170,9 +2180,14 @@ module Sequel
         true
       end
 
-      # Returning is always supported.
+      # MERGE RETURNING is supported on PostgreSQL 17+. Other RETURNING is supported
+      # on all supported PostgreSQL versions.
       def supports_returning?(type)
-        true
+        if type == :merge
+          server_version >= 170000
+        else
+          true
+        end
       end
 
       # PostgreSQL supports pattern matching via regular expressions
@@ -2295,6 +2310,12 @@ module Sequel
       end
       alias _merge_not_matched_sql _merge_matched_sql
 
+      # Support MERGE RETURNING on PostgreSQL 17+.
+      def _merge_when_sql(sql)
+        super
+        insert_returning_sql(sql) if uses_returning?(:merge)
+      end
+
       # Format TRUNCATE statement with PostgreSQL specific options.
       def _truncate_sql(table)
         to = @opts[:truncate_opts] || OPTS

data/lib/sequel/adapters/shared/sqlite.rb

@@ -245,7 +245,7 @@ module Sequel
             super
           end
         when :drop_column
-          if sqlite_version >= 33500
+          if sqlite_version >= 33500 && !indexes(table).any?{|_, h| h[:columns].include?(op[:name])}
             super
           else
             ocp = lambda{|oc| oc.delete_if{|c| c.to_s == op[:name].to_s}}

data/lib/sequel/connection_pool/sharded_threaded.rb

@@ -197,11 +197,8 @@ class Sequel::ShardedThreadedConnectionPool < Sequel::ThreadedConnectionPool
     timeout = @timeout
     timer = Sequel.start_timer
 
-    sync do
-      @waiters[server].wait(@mutex, timeout)
-      if conn = next_available(server)
-        return(allocated(server)[thread] = conn)
-      end
+    if conn = acquire_available(thread, server, timeout)
+      return conn
     end
 
     until conn = assign_connection(thread, server)
@@ -211,11 +208,8 @@ class Sequel::ShardedThreadedConnectionPool < Sequel::ThreadedConnectionPool
 
       # It's difficult to get to this point, it can only happen if there is a race condition
       # where a connection cannot be acquired even after the thread is signalled by the condition variable
-      sync do
-        @waiters[server].wait(@mutex, timeout - elapsed)
-        if conn = next_available(server)
-          return(allocated(server)[thread] = conn)
-        end
+      if conn = acquire_available(thread, server, timeout - elapsed)
+        return conn
       end
       # :nocov:
     end
@@ -223,6 +217,28 @@ class Sequel::ShardedThreadedConnectionPool < Sequel::ThreadedConnectionPool
     conn
   end
 
+  # Acquire a connection if one is already available, or waiting until it becomes available.
+  def acquire_available(thread, server, timeout)
+    sync do
+      # Check if connection was checked in between when assign_connection failed and now.
+      # This is very unlikely, but necessary to prevent a situation where the waiter
+      # will wait for a connection even though one has already been checked in.
+      # :nocov:
+      if conn = next_available(server)
+        return(allocated(server)[thread] = conn)
+      end
+      # :nocov:
+
+      @waiters[server].wait(@mutex, timeout)
+
+      # Connection still not available, could be because a connection was disconnected,
+      # may have to retry assign_connection to see if a new connection can be made.
+      if conn = next_available(server)
+        return(allocated(server)[thread] = conn)
+      end
+    end
+  end
+
   # Assign a connection to the thread, or return nil if one cannot be assigned.
   # The caller should NOT have the mutex before calling this.
   def assign_connection(thread, server)

data/lib/sequel/connection_pool/threaded.rb

@@ -143,11 +143,8 @@ class Sequel::ThreadedConnectionPool < Sequel::ConnectionPool
     timeout = @timeout
     timer = Sequel.start_timer
 
-    sync do
-      @waiter.wait(@mutex, timeout)
-      if conn = next_available
-        return(@allocated[thread] = conn)
-      end
+    if conn = acquire_available(thread, timeout)
+      return conn
     end
 
     until conn = assign_connection(thread)
@@ -157,11 +154,8 @@ class Sequel::ThreadedConnectionPool < Sequel::ConnectionPool
 
       # It's difficult to get to this point, it can only happen if there is a race condition
       # where a connection cannot be acquired even after the thread is signalled by the condition variable
-      sync do
-        @waiter.wait(@mutex, timeout - elapsed)
-        if conn = next_available
-          return(@allocated[thread] = conn)
-        end
+      if conn = acquire_available(thread, timeout - elapsed)
+        return conn
       end
       # :nocov:
     end
@@ -169,6 +163,28 @@ class Sequel::ThreadedConnectionPool < Sequel::ConnectionPool
     conn
   end
 
+  # Acquire a connection if one is already available, or waiting until it becomes available.
+  def acquire_available(thread, timeout)
+    sync do
+      # Check if connection was checked in between when assign_connection failed and now.
+      # This is very unlikely, but necessary to prevent a situation where the waiter
+      # will wait for a connection even though one has already been checked in.
+      # :nocov:
+      if conn = next_available
+        return(@allocated[thread] = conn)
+      end
+      # :nocov:
+
+      @waiter.wait(@mutex, timeout)
+
+      # Connection still not available, could be because a connection was disconnected,
+      # may have to retry assign_connection to see if a new connection can be made.
+      if conn = next_available
+        return(@allocated[thread] = conn)
+      end
+    end
+  end
+
   # Assign a connection to the thread, or return nil if one cannot be assigned.
   # The caller should NOT have the mutex before calling this.
   def assign_connection(thread)

data/lib/sequel/database/connecting.rb

@@ -270,28 +270,20 @@ module Sequel
       @single_threaded
     end
     
-    if RUBY_ENGINE == 'ruby' && RUBY_VERSION < '2.5'
-    # :nocov:
-      def synchronize(server=nil)
-        @pool.hold(server || :default){|conn| yield conn}
-      end
-    # :nocov:
-    else
-      # Acquires a database connection, yielding it to the passed block. This is
-      # useful if you want to make sure the same connection is used for all
-      # database queries in the block.  It is also useful if you want to gain
-      # direct access to the underlying connection object if you need to do
-      # something Sequel does not natively support.
-      #
-      # If a server option is given, acquires a connection for that specific
-      # server, instead of the :default server.
-      #
-      #   DB.synchronize do |conn|
-      #     # ...
-      #   end
-      def synchronize(server=nil, &block)
-        @pool.hold(server || :default, &block)
-      end
+    # Acquires a database connection, yielding it to the passed block. This is
+    # useful if you want to make sure the same connection is used for all
+    # database queries in the block.  It is also useful if you want to gain
+    # direct access to the underlying connection object if you need to do
+    # something Sequel does not natively support.
+    #
+    # If a server option is given, acquires a connection for that specific
+    # server, instead of the :default server.
+    #
+    #   DB.synchronize do |conn|
+    #     # ...
+    #   end
+    def synchronize(server=nil, &block)
+      @pool.hold(server || :default, &block)
     end
     
     # Attempts to acquire a database connection.  Returns true if successful.
@@ -343,6 +335,11 @@ module Sequel
       else
         @opts.dup
       end
+
+      if pr = opts[:connect_opts_proc]
+        pr.call(opts)
+      end
+
       opts.delete(:servers)
       opts
     end

data/lib/sequel/database/misc.rb

@@ -108,6 +108,9 @@ module Sequel
     # :cache_schema :: Whether schema should be cached for this Database instance
     # :check_string_typecast_bytesize :: Whether to check the bytesize of strings before typecasting.
     # :connect_sqls :: An array of sql strings to execute on each new connection, after :after_connect runs.
+    # :connect_opts_proc :: Callable object for modifying options hash used when connecting, designed for
+    #                       cases where the option values (e.g. password) are automatically rotated on
+    #                       a regular basis without involvement from the application using Sequel.
     # :default_string_column_size :: The default size of string columns, 255 by default.
     # :extensions :: Extensions to load into this Database instance.  Can be a symbol, array of symbols,
     #                or string with extensions separated by columns.  These extensions are loaded after

data/lib/sequel/plugins/association_pks.rb

@@ -294,7 +294,7 @@ module Sequel
           sch = klass.db_schema
 
           if primary_key.is_a?(Array)
-            if (cols = sch.values_at(*klass.primary_key)).all? && (convs = cols.map{|c| c[:type] == :integer}).all?
+            if (cols = sch.values_at(*klass.primary_key)).all? && (cols.map{|c| c[:type] == :integer}).all?
               db = model.db
               pks.map do |cpk|
                 cpk.map do |pk|

data/lib/sequel/plugins/tactical_eager_loading.rb

@@ -158,15 +158,19 @@ module Sequel
         end
 
         # Filter the objects used when tactical eager loading.
-        # By default, this removes frozen objects and objects that alreayd have the association loaded
+        # By default, this removes frozen objects and objects that alreayd have the association loaded,
+        # as well as objects where the reflection for the association is not the same as the receiver's
+        # reflection for the association.
         def _filter_tactical_eager_load_objects(opts)
           objects = defined?(super) ? super : retrieved_with.dup
+          name = opts[:name]
           if opts[:eager_reload]
             objects.reject!(&:frozen?)
           else
-            name = opts[:name]
             objects.reject!{|x| x.frozen? || x.associations.include?(name)}
           end
+          reflection = self.class.association_reflection(name)
+          objects.select!{|x| x.class.association_reflection(name).equal?(reflection)}
           objects
         end
       end

data/lib/sequel/plugins/validate_associated.rb

@@ -53,7 +53,7 @@ module Sequel
         def validate_associated_object(reflection, obj)
           return if reflection[:validate] == false
           association = reflection[:name]
-          if (reflection[:type] == :one_to_many || reflection[:type] == :one_to_one) && (key = reflection[:key]).is_a?(Symbol) && !(pk_val = obj.values[key])
+          if (reflection[:type] == :one_to_many || reflection[:type] == :one_to_one) && (key = reflection[:key]).is_a?(Symbol) && !(obj.values[key])
             p_key = pk unless pk.is_a?(Array)
             if p_key
               obj.values[key] = p_key

data/lib/sequel/version.rb

@@ -6,7 +6,7 @@ module Sequel
 
   # The minor version of Sequel.  Bumped for every non-patch level
   # release, generally around once a month.
-  MINOR = 81
+  MINOR = 82
 
   # The tiny version of Sequel.  Usually 0, only bumped for bugfix
   # releases that fix regressions from previous versions.

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sequel
 version: !ruby/object:Gem::Version
-  version: 5.81.0
+  version: 5.82.0
 platform: ruby
 authors:
 - Jeremy Evans
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-06-01 00:00:00.000000000 Z
+date: 2024-07-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bigdecimal
@@ -229,6 +229,7 @@ extra_rdoc_files:
 - doc/release_notes/5.8.0.txt
 - doc/release_notes/5.80.0.txt
 - doc/release_notes/5.81.0.txt
+- doc/release_notes/5.82.0.txt
 - doc/release_notes/5.9.0.txt
 files:
 - CHANGELOG
@@ -338,6 +339,7 @@ files:
 - doc/release_notes/5.8.0.txt
 - doc/release_notes/5.80.0.txt
 - doc/release_notes/5.81.0.txt
+- doc/release_notes/5.82.0.txt
 - doc/release_notes/5.9.0.txt
 - doc/schema_modification.rdoc
 - doc/security.rdoc