sequel 5.80.0 → 5.82.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ddf0e8e9009f39ca7f6dffca8aef10ef4fbdf22a8c5002def5ecea4042f38763
-  data.tar.gz: b9f3cb97273dd9885e8002a64e17bddd0a6db2f932d1c68ce97844e2ac843096
+  metadata.gz: f09a139a164322e0a0e52e9a58c79b2f463972363509c41bf50e7082c1f542b7
+  data.tar.gz: e7222b81a79111b9853565160f81cb18c72b341f18bec839046c9b49a4b199ea
 SHA512:
-  metadata.gz: 7387d403f32cb492abe6fad35d6a87a4ac274fc3602aee0f8afba38d9feb30578ee774de2b168a88d86ab740a41fa2a62333f695c0d2fa507fde775943917daa
-  data.tar.gz: 11b1c1e9daf92153585f158358ee85078b83decfca8bcf4569fa90e59335dfd123a0d8fddf8f6e58e166801029de23937279dc3aa746d0d3878a34dac90ce636
+  metadata.gz: d9f16395ad855ccbc4494bd2e1436b6b78f15ddbfd1c9b80d356040d99415a46a352f50042b2fc9ab23d29b65567dafec2fceb35c709498159b00a1402991ee6
+  data.tar.gz: a5693c2f3c3791c0216a5af9e933edaa41b0eeb030a3523e52a6951c666e720d0b12ec48ae3f46777ce617b27857f6519d7ce98ec1768a0c8226c4b494e501c1

data/CHANGELOG

@@ -1,3 +1,25 @@
+=== 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)
+
+* Skip Ruby internal caller locations when searching for caller locations in caller_logging and provenance extensions (jeremyevans) 
+
+* Add temporarily_release_connection Database extension for multithreaded transactional testing (jeremyevans)
+
 === 5.80.0 (2024-05-01)
 
 * Support Dataset#skip_locked on MariaDB 10.6+ (simi) (#2150)

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/code_order.rdoc

@@ -91,9 +91,11 @@ 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:
+`model_classes` is not a Sequel method, it indicates an array of model
+classes you defined. Instead of listing them manually, 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

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

@@ -0,0 +1,31 @@
+= New Features
+
+* A temporarily_release_connection Database extension has been added,
+  designed for multithreaded transactional testing.
+
+  This allows one thread to start a transaction, and then release
+  the connection back for usage by the connection pool, so that
+  other threads can operate on the connection object safely inside
+  the transaction.  This requires the connection pool be limited
+  to a single connection, to ensure that the released connection
+  can be reacquired.  It's not perfect, because if the connection
+  is disconnected and removed from the pool while temporarily
+  released, there is no way to handle that situation correctly.
+  Example:
+
+    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
+
+= Other Improvements
+
+* In the caller_logging and provenance extensions, Ruby internal
+  caller locations are skipped when trying to locate the appropriate
+  caller line to include.
+
+* A couple ignored block warnings in plugin apply methods have been
+  fixed on Ruby 3.4.

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/extensions/caller_logging.rb

@@ -37,6 +37,7 @@ module Sequel
   module CallerLogging
     SEQUEL_LIB_PATH = (File.expand_path('../../..', __FILE__) + '/').freeze
     RUBY_STDLIB = RbConfig::CONFIG["rubylibdir"]
+    INTERNAL = '<internal'
 
     # A regexp of caller lines to ignore, in addition to internal Sequel and Ruby code.
     attr_accessor :caller_logging_ignore
@@ -61,6 +62,7 @@ module Sequel
       c = caller.find do |line|
         !(line.start_with?(SEQUEL_LIB_PATH) ||
           line.start_with?(RUBY_STDLIB) ||
+          line.start_with?(INTERNAL) ||
           (ignore && line =~ ignore))
       end
 

data/lib/sequel/extensions/provenance.rb

@@ -38,6 +38,7 @@ module Sequel
     module Provenance
       SEQUEL_LIB_PATH = (File.expand_path('../../..', __FILE__) + '/').freeze
       RUBY_STDLIB = RbConfig::CONFIG["rubylibdir"]
+      INTERNAL = '<internal'
 
       if TRUE_FREEZE
         # Include provenance information when cloning datasets.
@@ -98,6 +99,7 @@ module Sequel
         caller.find do |line|
           !(line.start_with?(SEQUEL_LIB_PATH) ||
             line.start_with?(RUBY_STDLIB) ||
+            line.start_with?(INTERNAL) ||
             (ignore && line =~ ignore))
         end
       end

data/lib/sequel/extensions/temporarily_release_connection.rb

@@ -0,0 +1,178 @@
+# frozen-string-literal: true
+#
+# The temporarily_release_connection extension adds support for temporarily
+# releasing a checked out connection back to the connection pool.  It is
+# designed for use in multithreaded transactional integration tests, allowing
+# a connection to start a transaction in one thread, but be temporarily
+# released back to the connection pool, so it can be operated on safely
+# by multiple threads inside a block. For example, the main thread could be
+# running tests that send web requests, and a separate thread running a web
+# server that is responding to those requests, and the same connection and
+# transaction would be used for both.
+#
+# To load the extension into the database:
+#
+#   DB.extension :temporarily_release_connection
+#
+# After the extension is loaded, call the +temporarily_release_connection+
+# method with the connection object to temporarily release the connection
+# back to the pool. Example:
+#
+#   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
+#
+# For sharded connection pools, the second argument to +temporarily_release_connection+
+# is respected, and specifies the server on which to temporarily release the connection.
+#
+# The temporarily_release_connection extension is only supported with the
+# threaded and timed_queue connection pools that ship with Sequel (and the sharded
+# versions of each).  To make sure that same connection object can be reacquired, it
+# is only supported if the maximum connection pool size is 1, so set the Database
+# :max_connections option to 1 if you plan to use this extension.
+#
+# If the +temporarily_release_connection+ method cannot reacquire the same connection
+# it released to the pool, it will raise a Sequel::UnableToReacquireConnectionError
+# exception.  This should only happen if the connection has been disconnected
+# while it was temporarily released.  If this error is raised, Database#transaction
+# will not rollback the transaction, since the connection object is likely no longer
+# valid, and on poorly written database drivers, that could cause the process to crash.
+#
+# Related modules: Sequel::TemporarilyReleaseConnection,
+# Sequel::UnableToReacquireConnectionError
+
+#
+module Sequel
+  # Error class raised if the connection pool does not provide the same connection
+  # object when checking a temporarily released connection out.
+  class UnableToReacquireConnectionError < Error
+  end
+
+  module TemporarilyReleaseConnection
+    module DatabaseMethods
+      # Temporarily release the connection back to the connection pool for the
+      # duration of the block.
+      def temporarily_release_connection(conn, server=:default, &block)
+        pool.temporarily_release_connection(conn, server, &block)
+      end
+
+      private
+
+      # Do nothing if UnableToReacquireConnectionError is raised, as it is
+      # likely the connection is not in a usable state.
+      def rollback_transaction(conn, opts)
+        return if UnableToReacquireConnectionError === $!
+        super
+      end
+    end
+
+    module PoolMethods
+      # Temporarily release a currently checked out connection, then yield to the block. Reacquire the same
+      # connection upon the exit of the block.
+      def temporarily_release_connection(conn, server)
+        t = Sequel.current
+        raise Error, "connection not currently checked out" unless conn.equal?(trc_owned_connection(t, server))
+
+        begin
+          trc_release(t, conn, server)
+          yield
+        ensure
+          c = trc_acquire(t, server)
+          unless conn.equal?(c)
+            raise UnableToReacquireConnectionError, "reacquired connection not the same as initial connection"
+          end
+        end
+      end
+    end
+
+    module TimedQueue
+      private
+
+      def trc_owned_connection(t, server)
+        owned_connection(t)
+      end
+
+      def trc_release(t, conn, server)
+        release(t)
+      end
+
+      def trc_acquire(t, server)
+        acquire(t)
+      end
+    end
+
+    module ShardedTimedQueue
+      # Normalize the server name for sharded connection pools
+      def temporarily_release_connection(conn, server)
+        server = pick_server(server)
+        super
+      end
+
+      private
+
+      def trc_owned_connection(t, server)
+        owned_connection(t, server)
+      end
+
+      def trc_release(t, conn, server)
+        release(t, conn, server)
+      end
+
+      def trc_acquire(t, server)
+        acquire(t, server)
+      end
+    end
+
+    module ThreadedBase
+      private
+
+      def trc_release(t, conn, server)
+        sync{super}
+      end
+    end
+
+    module Threaded
+      include TimedQueue
+      include ThreadedBase
+    end
+
+    module ShardedThreaded
+      include ShardedTimedQueue
+      include ThreadedBase
+    end
+  end
+
+  trc = TemporarilyReleaseConnection
+  trc_map = {
+    :threaded => trc::Threaded,
+    :sharded_threaded => trc::ShardedThreaded,
+    :timed_queue => trc::TimedQueue,
+    :sharded_timed_queue => trc::ShardedTimedQueue,
+  }.freeze
+
+  Database.register_extension(:temporarily_release_connection) do |db|
+    unless pool_mod = trc_map[db.pool.pool_type]
+      raise(Error, "temporarily_release_connection extension not supported for connection pool type #{db.pool.pool_type}")
+    end
+
+    case db.pool.pool_type
+    when :threaded, :sharded_threaded
+      if db.opts[:connection_handling] == :disconnect
+        raise Error, "temporarily_release_connection extension not supported with connection_handling: :disconnect option"
+      end
+    end
+
+    unless db.pool.max_size == 1
+      raise Error, "temporarily_release_connection extension not supported unless :max_connections option is 1"
+    end
+
+    db.extend(trc::DatabaseMethods)
+    db.pool.extend(trc::PoolMethods)
+    db.pool.extend(pool_mod)
+  end
+
+  private_constant :TemporarilyReleaseConnection
+end

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/column_encryption.rb

@@ -586,7 +586,7 @@ module Sequel
         end
       end
 
-      def self.apply(model, opts=OPTS)
+      def self.apply(model, opts=OPTS, &_)
         model.plugin :serialization
       end
 

data/lib/sequel/plugins/input_transformer.rb

@@ -24,7 +24,7 @@ module Sequel
     #   # Make the Album class support input transformers 
     #   Album.plugin :input_transformer
     module InputTransformer
-      def self.apply(model, *)
+      def self.apply(model, *, &_)
         model.instance_exec do
           @input_transformers = {}
           @skip_input_transformer_columns = {}

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 = 80
+  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.80.0
+  version: 5.82.0
 platform: ruby
 authors:
 - Jeremy Evans
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-05-01 00:00:00.000000000 Z
+date: 2024-07-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bigdecimal
@@ -228,6 +228,8 @@ extra_rdoc_files:
 - doc/release_notes/5.79.0.txt
 - 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
@@ -336,6 +338,8 @@ files:
 - doc/release_notes/5.79.0.txt
 - 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
@@ -522,6 +526,7 @@ files:
 - lib/sequel/extensions/symbol_as.rb
 - lib/sequel/extensions/symbol_as_refinement.rb
 - lib/sequel/extensions/synchronize_sql.rb
+- lib/sequel/extensions/temporarily_release_connection.rb
 - lib/sequel/extensions/thread_local_timezones.rb
 - lib/sequel/extensions/to_dot.rb
 - lib/sequel/extensions/transaction_connection_validator.rb