sequel 5.69.0 → 5.70.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dc06712b20f476b85d0a08a4d94d96a2c74e0a632053baeecefbecd4cd60d476
-  data.tar.gz: dd5fdc130ad5a4fb19579c45e426d2a2da6431b14af18dd87fd8785b45fb0684
+  metadata.gz: 780e8bd3203a4aa27f70c94dd2ddd29e28826ec7b74b86296a2571d40ff2a74a
+  data.tar.gz: f600cfad2e5401f2c1150838ecacac0cd34ba38da4a69bd3afd580dbadaee35f
 SHA512:
-  metadata.gz: e0c1138064b489cbcdc7740f047095279e1f6e9a71e2ef1502359fbc440e8a2caed3009745d0aadbd51c7d2c13dbc6b971150f370bbe10a0f2e566e0cf219722
-  data.tar.gz: 364735d4186439b97d2d7e5a83c3ddd13fdcf5af433b97d1892898b3f04115191a4dc77fd5d711a7ad715e8a707c5389aac6bfb539840464cff53e6d3f04ff6f
+  metadata.gz: b22192e34739b2158a543f18f51b52b44063b86b02c6968a8f8e1ff2deec8338fa4f81176a4f5f2b27ace6fcefe9d3511ccaa73c43e2b660743a3a736f303080
+  data.tar.gz: 4540e3f53f53d6fe8b7a22212ab7d6678502e87bf67a5081c22d1da02ea8ea2090589e384fe17e4ca454c0c4c45358f1aaed1772d27e7732f7f68071e5914ea6

data/CHANGELOG

@@ -1,3 +1,19 @@
+=== 5.70.0 (2023-07-01)
+
+* Make static_cache plugin better handle cases where forbid_lazy_load plugin is already loaded (jeremyevans)
+
+* Fix ShardedThreadedConnectionPool#remove_server to disconnect all connections if removing multiple servers (jeremyevans)
+
+* Support SEQUEL_DEFAULT_CONNECTION_POOL environment variable for choosing connection pool when :pool_class Database option is not set (jeremyevans)
+
+* Add sharded_timed_queue connection pool (jeremyevans)
+
+* Make connection_{validator,expiration} and async_thread_pool extensions work with timed_queue connection pool (jeremyevans)
+
+* Make connection_{validator,expiration} extensions raise error when used with single threaded pools (HoneyryderChuck, jeremyevans) (#2049)
+
+* Workaround possible resource starvation in threaded connection pool (ioquatix) (#2048)
+
 === 5.69.0 (2023-06-01)
 
 * Avoid unsupported flag warning when using the mysql adapter with ruby-mysql 3+ (jeremyevans)

data/doc/release_notes/5.70.0.txt

@@ -0,0 +1,35 @@
+= New Features
+
+* A sharded_timed_queue connection pool has been added. This offers
+  most of the same features as the sharded_threaded connection pool,
+  but uses the new Queue#pop :timeout features added in Ruby 3.2 to
+  allow for a simpler and possibly faster and more robust
+  implementation.
+
+* If a :pool_class option is not specified when creating a Database,
+  Sequel will now look at the SEQUEL_DEFAULT_CONNECTION_POOL
+  environment variable to determine the connection pool class to use.
+  This allows you to set SEQUEL_DEFAULT_CONNECTION_POOL=timed_queue
+  on Ruby 3.2 to test with the timed_queue connection pool without
+  making any code changes.  If the :servers Database option is given,
+  Sequel will automatically use the sharded version of the connection
+  pool specified by SEQUEL_DEFAULT_CONNECTION_POOL.
+
+= Other Improvements
+
+* The connection_validator, connection_expiration, and
+  async_thread_pool extensions now work with the timed_queue and
+  sharded_timed_queue connection pools.
+
+* The sharded_threaded connection pool now disconnects connections
+  for all specified servers instead of just the last specified server
+  when using remove_server.
+
+* The static_cache plugin now recognizes when the forbid_lazy_load
+  plugin is already loaded, and does not return instances that
+  forbid lazy load for methods that return a single object, such as
+  Database.{[],cache_get_pk,first}.
+
+* Sequel now displays an informative error message if attempting to
+  load the connection_validator or connection_expiration extensions
+  when using the single threaded connection pool.

data/lib/sequel/connection_pool/sharded_threaded.rb

@@ -2,7 +2,7 @@
 
 require_relative 'threaded'
 
-# The slowest and most advanced connection, dealing with both multi-threaded
+# The slowest and most advanced connection pool, dealing with both multi-threaded
 # access and configurations with multiple shards/servers.
 #
 # In addition, this pool subclass also handles scheduling in-use connections
@@ -112,7 +112,7 @@ class Sequel::ShardedThreadedConnectionPool < Sequel::ThreadedConnectionPool
   # available, creates a new connection.  Passes the connection to the supplied
   # block:
   # 
-  #   pool.hold {|conn| conn.execute('DROP TABLE posts')}
+  #   pool.hold(:server1) {|conn| conn.execute('DROP TABLE posts')}
   # 
   # Pool#hold is re-entrant, meaning it can be called recursively in
   # the same thread without blocking.
@@ -145,12 +145,13 @@ class Sequel::ShardedThreadedConnectionPool < Sequel::ThreadedConnectionPool
   # except that after it is used, future requests for the server will use the
   # :default server instead.
   def remove_servers(servers)
-    conns = nil
+    conns = []
+    raise(Sequel::Error, "cannot remove default server") if servers.include?(:default)
+
     sync do
-      raise(Sequel::Error, "cannot remove default server") if servers.include?(:default)
       servers.each do |server|
         if @servers.include?(server)
-          conns = disconnect_server_connections(server)
+          conns.concat(disconnect_server_connections(server))
           @waiters.delete(server)
           @available_connections.delete(server)
           @allocated.delete(server)
@@ -159,9 +160,9 @@ class Sequel::ShardedThreadedConnectionPool < Sequel::ThreadedConnectionPool
       end
     end
 
-    if conns
-      disconnect_connections(conns)
-    end
+    nil
+  ensure
+    disconnect_connections(conns)
   end
 
   # Return an array of symbols for servers in the connection pool.
@@ -186,7 +187,7 @@ class Sequel::ShardedThreadedConnectionPool < Sequel::ThreadedConnectionPool
   # is available. The calling code should NOT already have the mutex when
   # calling this.
   #
-  # This should return a connection is one is available within the timeout,
+  # This should return a connection if one is available within the timeout,
   # or nil if a connection could not be acquired within the timeout.
   def acquire(thread, server)
     if conn = assign_connection(thread, server)
@@ -325,7 +326,7 @@ class Sequel::ShardedThreadedConnectionPool < Sequel::ThreadedConnectionPool
   # Create the maximum number of connections immediately.  The calling code should
   # NOT have the mutex before calling this.
   def preconnect(concurrent = false)
-    conn_servers = @servers.keys.map!{|s| Array.new(max_size - _size(s), s)}.flatten!
+    conn_servers = sync{@servers.keys}.map!{|s| Array.new(max_size - _size(s), s)}.flatten!
 
     if concurrent
       conn_servers.map!{|s| Thread.new{[s, make_new(s)]}}.map!(&:value)

data/lib/sequel/connection_pool/sharded_timed_queue.rb

@@ -0,0 +1,374 @@
+# frozen-string-literal: true
+
+# :nocov:
+raise LoadError, "Sequel::ShardedTimedQueueConnectionPool is only available on Ruby 3.2+" unless RUBY_VERSION >= '3.2'
+# :nocov:
+
+# A connection pool allowing multi-threaded access to a sharded pool of connections,
+# using a timed queue (only available in Ruby 3.2+).
+class Sequel::ShardedTimedQueueConnectionPool < Sequel::ConnectionPool
+  # The maximum number of connections this pool will create per shard.
+  attr_reader :max_size
+
+  # The following additional options are respected:
+  # :max_connections :: The maximum number of connections the connection pool
+  #                     will open (default 4)
+  # :pool_timeout :: The amount of seconds to wait to acquire a connection
+  #                  before raising a PoolTimeout (default 5)
+  # :servers :: A hash of servers to use.  Keys should be symbols.  If not
+  #             present, will use a single :default server.
+  # :servers_hash :: The base hash to use for the servers.  By default,
+  #                  Sequel uses Hash.new(:default).  You can use a hash with a default proc
+  #                  that raises an error if you want to catch all cases where a nonexistent
+  #                  server is used.
+  def initialize(db, opts = OPTS)
+    super
+
+    @max_size = Integer(opts[:max_connections] || 4)
+    raise(Sequel::Error, ':max_connections must be positive') if @max_size < 1
+    @mutex = Mutex.new  
+    @timeout = Float(opts[:pool_timeout] || 5)
+
+    @allocated = {}
+    @sizes = {}
+    @queues = {}
+    @servers = opts.fetch(:servers_hash, Hash.new(:default))
+
+    add_servers([:default])
+    add_servers(opts[:servers].keys) if opts[:servers]
+  end
+
+  # Adds new servers to the connection pool.  Allows for dynamic expansion of the potential replicas/shards
+  # at runtime. +servers+ argument should be an array of symbols. 
+  def add_servers(servers)
+    sync do
+      servers.each do |server|
+        next if @servers.has_key?(server)
+
+        @servers[server] = server
+        @sizes[server] = 0
+        @queues[server] = Queue.new
+        (@allocated[server] = {}).compare_by_identity
+      end
+    end
+    nil
+  end
+  
+  # Yield all of the available connections, and the one currently allocated to
+  # this thread (if one is allocated).  This will not yield connections currently
+  # allocated to other threads, as it is not safe to operate on them.
+  def all_connections
+    thread = Sequel.current
+    sync{@queues.to_a}.each do |server, queue|
+      if conn = owned_connection(thread, server)
+        yield conn
+      end
+
+      # Use a hash to record all connections already seen.  As soon as we
+      # come across a connection we've already seen, we stop the loop.
+      conns = {}
+      conns.compare_by_identity
+      while true
+        conn = nil
+        begin
+          break unless (conn = queue.pop(timeout: 0)) && !conns[conn]
+          conns[conn] = true
+          yield conn
+        ensure
+          queue.push(conn) if conn
+        end
+      end
+    end
+
+    nil
+  end
+  
+  # Removes all connections currently in the pool's queue. This method has the effect of 
+  # disconnecting from the database, assuming that no connections are currently
+  # being used.
+  # 
+  # Once a connection is requested using #hold, the connection pool
+  # creates new connections to the database.
+  #
+  # If the :server option is provided, it should be a symbol or array of symbols,
+  # and then the method will only disconnect connectsion from those specified shards.
+  def disconnect(opts=OPTS)
+    (opts[:server] ? Array(opts[:server]) : sync{@servers.keys}).each do |server|
+      raise Sequel::Error, "invalid server" unless queue = sync{@queues[server]}
+      while conn = queue.pop(timeout: 0)
+        disconnect_pool_connection(conn, server)
+      end
+      fill_queue(server)
+    end
+    nil
+  end
+
+  # Chooses the first available connection for the given server, or if none are
+  # available, creates a new connection.  Passes the connection to the supplied
+  # block:
+  # 
+  #   pool.hold(:server1) {|conn| conn.execute('DROP TABLE posts')}
+  # 
+  # Pool#hold is re-entrant, meaning it can be called recursively in
+  # the same thread without blocking.
+  #
+  # If no connection is immediately available and the pool is already using the maximum
+  # number of connections, Pool#hold will block until a connection
+  # is available or the timeout expires.  If the timeout expires before a
+  # connection can be acquired, a Sequel::PoolTimeout is raised.
+  def hold(server=:default)
+    server = pick_server(server)
+    t = Sequel.current
+    if conn = owned_connection(t, server)
+      return yield(conn)
+    end
+
+    begin
+      conn = acquire(t, server)
+      yield conn
+    rescue Sequel::DatabaseDisconnectError, *@error_classes => e
+      if disconnect_error?(e)
+        oconn = conn
+        conn = nil
+        disconnect_pool_connection(oconn, server) if oconn
+        sync{@allocated[server].delete(t)}
+        fill_queue(server)
+      end
+      raise
+    ensure
+      release(t, conn, server) if conn
+    end
+  end
+
+  # The total number of connections in the pool. Using a non-existant server will return nil.
+  def size(server=:default)
+    sync{@sizes[server]}
+  end
+  
+  # Remove servers from the connection pool. Similar to disconnecting from all given servers,
+  # except that after it is used, future requests for the servers will use the
+  # :default server instead.
+  #
+  # Note that an error will be raised if there are any connections currently checked
+  # out for the given servers.
+  def remove_servers(servers)
+    conns = []
+    raise(Sequel::Error, "cannot remove default server") if servers.include?(:default)
+
+    sync do
+      servers.each do |server|
+        next unless @servers.has_key?(server)
+
+        queue = @queues[server]
+
+        while conn = queue.pop(timeout: 0)
+          @sizes[server] -= 1
+          conns << conn
+        end
+
+        unless @sizes[server] == 0
+          raise Sequel::Error, "cannot remove server #{server} as it has allocated connections"
+        end
+
+        @servers.delete(server)
+        @sizes.delete(server)
+        @queues.delete(server)
+        @allocated.delete(server)
+      end
+    end
+
+    nil
+  ensure
+    disconnect_connections(conns)
+  end
+
+  # Return an array of symbols for servers in the connection pool.
+  def servers
+    sync{@servers.keys}
+  end
+
+  def pool_type
+    :sharded_timed_queue
+  end
+  
+  private
+
+  # Create a new connection, after the pool's current size has already
+  # been updated to account for the new connection.  If there is an exception
+  # when creating the connection, decrement the current size.
+  #
+  # This should only be called after can_make_new?.  If there is an exception
+  # between when can_make_new? is called and when preallocated_make_new
+  # is called, it has the effect of reducing the maximum size of the
+  # connection pool by 1, since the current size of the pool will show a
+  # higher number than the number of connections allocated or
+  # in the queue.
+  #
+  # Calling code should not have the mutex when calling this.
+  def preallocated_make_new(server)
+    make_new(server)
+  rescue Exception
+    sync{@sizes[server] -= 1}
+    raise
+  end
+
+  # Disconnect all available connections immediately, and schedule currently allocated connections for disconnection
+  # as soon as they are returned to the pool. The calling code should NOT
+  # have the mutex before calling this.
+  def disconnect_connections(conns)
+    conns.each{|conn| disconnect_connection(conn)}
+  end
+
+  # Decrement the current size of the pool for the server when disconnecting connections.
+  #
+  # Calling code should not have the mutex when calling this.
+  def disconnect_pool_connection(conn, server)
+    sync{@sizes[server] -= 1}
+    disconnect_connection(conn)
+  end
+
+  # If there are any threads waiting on the queue, try to create
+  # new connections in a separate thread if the pool is not yet at the
+  # maximum size.
+  #
+  # The reason for this method is to handle cases where acquire
+  # could not retrieve a connection immediately, and the pool
+  # was already at the maximum size.  In that case, the acquire will
+  # wait on the queue until the timeout.  This method is called
+  # after disconnecting to potentially add new connections to the
+  # pool, so the threads that are currently waiting for connections
+  # do not timeout after the pool is no longer full.
+  def fill_queue(server)
+    queue = sync{@queues[server]}
+    if queue.num_waiting > 0
+      Thread.new do
+        while queue.num_waiting > 0 && (conn = try_make_new(server))
+          queue.push(conn)
+        end
+      end
+    end
+  end
+
+  # Whether the given size is less than the maximum size of the pool.
+  # In that case, the pool's current size is incremented.  If this
+  # method returns true, space in the pool for the connection is
+  # preallocated, and preallocated_make_new should be called to
+  # create the connection.
+  #
+  # Calling code should have the mutex when calling this.
+  def can_make_new?(server, current_size)
+    if @max_size > current_size
+      @sizes[server] += 1
+    end
+  end
+
+  # Try to make a new connection if there is space in the pool.
+  # If the pool is already full, look for dead threads/fibers and
+  # disconnect the related connections.
+  #
+  # Calling code should not have the mutex when calling this.
+  def try_make_new(server)
+    return preallocated_make_new(server) if sync{can_make_new?(server, @sizes[server])}
+
+    to_disconnect = nil
+    do_make_new = false
+
+    sync do
+      current_size = @sizes[server]
+      alloc = @allocated[server]
+      alloc.keys.each do |t|
+        unless t.alive?
+          (to_disconnect ||= []) << alloc.delete(t)
+          current_size -= 1
+        end
+      end
+    
+      do_make_new = true if can_make_new?(server, current_size)
+    end
+
+    begin
+      preallocated_make_new(server) if do_make_new
+    ensure
+      if to_disconnect
+        to_disconnect.each{|conn| disconnect_pool_connection(conn, server)}
+        fill_queue(server)
+      end
+    end
+  end
+  
+  # Assigns a connection to the supplied thread, if one
+  # is available.
+  #
+  # This should return a connection if one is available within the timeout,
+  # or raise PoolTimeout if a connection could not be acquired within the timeout.
+  #
+  # Calling code should not have the mutex when calling this.
+  def acquire(thread, server)
+    queue = sync{@queues[server]}
+    if conn = queue.pop(timeout: 0) || try_make_new(server) || queue.pop(timeout: @timeout)
+      sync{@allocated[server][thread] = conn}
+    else
+      name = db.opts[:name]
+      raise ::Sequel::PoolTimeout, "timeout: #{@timeout}, server: #{server}#{", database name: #{name}" if name}"
+    end
+  end
+
+  # Returns the connection owned by the supplied thread for the given server,
+  # if any. The calling code should NOT already have the mutex before calling this.
+  def owned_connection(thread, server)
+    sync{@allocated[server][thread]}
+  end
+
+  # If the server given is in the hash, return it, otherwise, return the default server.
+  def pick_server(server)
+    sync{@servers[server]}
+  end
+  
+  # Create the maximum number of connections immediately. This should not be called
+  # with a true argument unless no code is currently operating on the database.
+  #
+  # Calling code should not have the mutex when calling this.
+  def preconnect(concurrent = false)
+    conn_servers = sync{@servers.keys}.map!{|s| Array.new(@max_size - @sizes[s], s)}.flatten!
+
+    if concurrent
+      conn_servers.map! do |server|
+        queue = sync{@queues[server]}
+        Thread.new do 
+          if conn = try_make_new(server)
+            queue.push(conn)
+          end
+        end
+      end.each(&:value)
+    else
+      conn_servers.each do |server|
+        if conn = try_make_new(server)
+          sync{@queues[server]}.push(conn)
+        end
+      end
+    end
+
+    nil
+  end
+
+  # Releases the connection assigned to the supplied thread back to the pool.
+  #
+  # Calling code should not have the mutex when calling this.
+  def release(thread, _, server)
+    checkin_connection(sync{@allocated[server].delete(thread)}, server)
+    nil
+  end
+
+  # Adds a connection to the queue of available connections, returns the connection.
+  def checkin_connection(conn, server)
+    sync{@queues[server]}.push(conn)
+    conn
+  end
+
+  # Yield to the block while inside the mutex.
+  #
+  # Calling code should not have the mutex when calling this.
+  def sync
+    @mutex.synchronize{yield}
+  end
+end

data/lib/sequel/connection_pool/threaded.rb

@@ -274,6 +274,12 @@ class Sequel::ThreadedConnectionPool < Sequel::ConnectionPool
     end
 
     @waiter.signal
+    
+    # Ensure that after signalling the condition, some other thread is given the
+    # opportunity to acquire the mutex.
+    # See <https://github.com/socketry/async/issues/99> for more context.
+    sleep(0)
+    
     nil
   end
 

data/lib/sequel/connection_pool/timed_queue.rb

@@ -81,7 +81,7 @@ class Sequel::TimedQueueConnectionPool < Sequel::ConnectionPool
   # connection can be acquired, a Sequel::PoolTimeout is raised.
   def hold(server=nil)
     t = Sequel.current
-    if conn = sync{@allocated[t]}
+    if conn = owned_connection(t)
       return yield(conn)
     end
 
@@ -223,8 +223,14 @@ class Sequel::TimedQueueConnectionPool < Sequel::ConnectionPool
     end
   end
 
+  # Returns the connection owned by the supplied thread,
+  # if any. The calling code should NOT already have the mutex before calling this.
+  def owned_connection(thread)
+    sync{@allocated[thread]}
+  end
+  
   # Create the maximum number of connections immediately. This should not be called
-  # with a true argument unles no code is currently operating on the database.
+  # with a true argument unless no code is currently operating on the database.
   #
   # Calling code should not have the mutex when calling this.
   def preconnect(concurrent = false)
@@ -245,7 +251,14 @@ class Sequel::TimedQueueConnectionPool < Sequel::ConnectionPool
   #
   # Calling code should not have the mutex when calling this.
   def release(thread)
-    @queue.push(sync{@allocated.delete(thread)})
+    checkin_connection(sync{@allocated.delete(thread)})
+    nil
+  end
+
+  # Adds a connection to the queue of available connections, returns the connection.
+  def checkin_connection(conn)
+    @queue.push(conn)
+    conn
   end
 
   # Yield to the block while inside the mutex.

data/lib/sequel/connection_pool.rb

@@ -32,6 +32,7 @@ class Sequel::ConnectionPool
     :sharded_threaded => :ShardedThreadedConnectionPool,
     :sharded_single => :ShardedSingleConnectionPool,
     :timed_queue => :TimedQueueConnectionPool,
+    :sharded_timed_queue => :ShardedTimedQueueConnectionPool,
   }
   POOL_CLASS_MAP.to_a.each{|k, v| POOL_CLASS_MAP[k.to_s] = v}
   POOL_CLASS_MAP.freeze
@@ -42,7 +43,8 @@ class Sequel::ConnectionPool
     # Return a pool subclass instance based on the given options.  If a <tt>:pool_class</tt>
     # option is provided is provided, use that pool class, otherwise
     # use a new instance of an appropriate pool subclass based on the
-    # <tt>:single_threaded</tt> and <tt>:servers</tt> options.
+    # +SEQUEL_DEFAULT_CONNECTION_POOL+ environment variable if set, or
+    # the <tt>:single_threaded</tt> and <tt>:servers</tt> options, otherwise.
     def get_pool(db, opts = OPTS)
       connection_pool_class(opts).new(db, opts)
     end
@@ -62,9 +64,14 @@ class Sequel::ConnectionPool
         end
 
         pc
+      elsif pc = ENV['SEQUEL_DEFAULT_CONNECTION_POOL']
+        pc = "sharded_#{pc}" if opts[:servers] && !pc.start_with?('sharded_')
+        connection_pool_class(:pool_class=>pc)
       else
         pc = if opts[:single_threaded]
           opts[:servers] ? :sharded_single : :single
+        #elsif RUBY_VERSION >= '3.2' # SEQUEL6 or maybe earlier
+        #  opts[:servers] ? :sharded_timed_queue : :timed_queue
         else
           opts[:servers] ? :sharded_threaded : :threaded
         end

data/lib/sequel/extensions/async_thread_pool.rb

@@ -338,8 +338,9 @@ module Sequel
     module DatabaseMethods
       def self.extended(db)
         db.instance_exec do
-          unless pool.pool_type == :threaded || pool.pool_type == :sharded_threaded
-            raise Error, "can only load async_thread_pool extension if using threaded or sharded_threaded connection pool"
+          case pool.pool_type
+          when :single, :sharded_single
+            raise Error, "cannot load async_thread_pool extension if using single or sharded_single connection pool"
           end
 
           num_async_threads = opts[:num_async_threads] ? typecast_value_integer(opts[:num_async_threads]) : (Integer(opts[:max_connections] || 4))

data/lib/sequel/extensions/connection_expiration.rb

@@ -15,16 +15,16 @@
 #
 #   DB.pool.connection_expiration_timeout = 3600 # 1 hour
 #
-# Note that this extension only affects the default threaded
-# and the sharded threaded connection pool.  The single
-# threaded and sharded single threaded connection pools are
-# not affected.  As the only reason to use the single threaded
+# Note that this extension does not work with the single
+# threaded and sharded single threaded connection pools.
+# As the only reason to use the single threaded
 # pools is for speed, and this extension makes the connection
 # pool slower, there's not much point in modifying this
 # extension to work with the single threaded pools.  The
-# threaded pools work fine even in single threaded code, so if
-# you are currently using a single threaded pool and want to
-# use this extension, switch to using a threaded pool.
+# non-single threaded pools work fine even in single threaded
+# code, so if you are currently using a single threaded pool
+# and want to use this extension, switch to using another
+# pool.
 #
 # Related module: Sequel::ConnectionExpiration
 
@@ -45,6 +45,11 @@ module Sequel
 
     # Initialize the data structures used by this extension.
     def self.extended(pool)
+      case pool.pool_type
+      when :single, :sharded_single
+        raise Error, "cannot load connection_expiration extension if using single or sharded_single connection pool"
+      end
+
       pool.instance_exec do
         sync do
           @connection_expiration_timestamps ||= {}
@@ -79,8 +84,9 @@ module Sequel
            (cet = sync{@connection_expiration_timestamps[conn]}) &&
            Sequel.elapsed_seconds_since(cet[0]) > cet[1]
 
-          if pool_type == :sharded_threaded
-            sync{allocated(a.last).delete(Sequel.current)}
+          case pool_type
+          when :sharded_threaded, :sharded_timed_queue
+            sync{@allocated[a.last].delete(Sequel.current)}
           else
             sync{@allocated.delete(Sequel.current)}
           end

data/lib/sequel/extensions/connection_validator.rb

@@ -34,16 +34,16 @@
 # web requests to the number to connections in the database
 # connection pool.
 #
-# Note that this extension only affects the default threaded
-# and the sharded threaded connection pool.  The single
-# threaded and sharded single threaded connection pools are
-# not affected.  As the only reason to use the single threaded
+# Note that this extension does not work with the single
+# threaded and sharded single threaded connection pools.
+# As the only reason to use the single threaded
 # pools is for speed, and this extension makes the connection
 # pool slower, there's not much point in modifying this
 # extension to work with the single threaded pools.  The
-# threaded pools work fine even in single threaded code, so if
-# you are currently using a single threaded pool and want to
-# use this extension, switch to using a threaded pool.
+# non-single threaded pools work fine even in single threaded
+# code, so if you are currently using a single threaded pool
+# and want to use this extension, switch to using another
+# pool.
 #
 # Related module: Sequel::ConnectionValidator
 
@@ -61,6 +61,11 @@ module Sequel
 
     # Initialize the data structures used by this extension.
     def self.extended(pool)
+      case pool.pool_type
+      when :single, :sharded_single
+        raise Error, "cannot load connection_validator extension if using single or sharded_single connection pool"
+      end
+
       pool.instance_exec do
         sync do
           @connection_timestamps ||= {}
@@ -103,8 +108,9 @@ module Sequel
            Sequel.elapsed_seconds_since(timer) > @connection_validation_timeout &&
            !db.valid_connection?(conn)
 
-          if pool_type == :sharded_threaded
-            sync{allocated(a.last).delete(Sequel.current)}
+          case pool_type
+          when :sharded_threaded, :sharded_timed_queue
+            sync{@allocated[a.last].delete(Sequel.current)}
           else
             sync{@allocated.delete(Sequel.current)}
           end
@@ -120,4 +126,3 @@ module Sequel
 
   Database.register_extension(:connection_validator){|db| db.pool.extend(ConnectionValidator)}
 end
-

data/lib/sequel/extensions/server_block.rb

@@ -69,7 +69,8 @@ module Sequel
     # Also defines the with_server method on the receiver for easy use.
     def self.extended(db)
       pool = db.pool
-      if defined?(ShardedThreadedConnectionPool) && pool.is_a?(ShardedThreadedConnectionPool)
+      case pool.pool_type
+      when :sharded_threaded, :sharded_timed_queue
         pool.extend(ThreadedServerBlock)
         pool.instance_variable_set(:@default_servers, {})
       else

data/lib/sequel/plugins/static_cache.rb

@@ -64,6 +64,9 @@ module Sequel
       def self.configure(model, opts=OPTS)
         model.instance_exec do
           @static_cache_frozen = opts.fetch(:frozen, true)
+          if @static_cache_frozen && defined?(::Sequel::Plugins::ForbidLazyLoad::ClassMethods) && is_a?(::Sequel::Plugins::ForbidLazyLoad::ClassMethods)
+            extend ForbidLazyLoadClassMethods
+          end
           load_cache
         end
       end
@@ -246,6 +249,41 @@ module Sequel
         end
       end
 
+      module ForbidLazyLoadClassMethods
+        # Do not forbid lazy loading for single object retrieval.
+        def cache_get_pk(pk)
+          primary_key_lookup(pk)
+        end
+
+        # Use static cache to return first arguments.
+        def first(*args)
+          if !defined?(yield) && args.empty?
+            if o = @all.first
+              _static_cache_frozen_copy(o)
+            end
+          else
+            super
+          end
+        end
+
+        private
+
+        # Return a frozen copy of the object that does not have lazy loading
+        # forbidden.
+        def _static_cache_frozen_copy(o)
+          o = call(Hash[o.values])
+          o.errors.freeze
+          o.freeze
+        end
+
+        # Do not forbid lazy loading for single object retrieval.
+        def primary_key_lookup(pk)
+          if o = cache[pk]
+            _static_cache_frozen_copy(o)
+          end
+        end
+      end
+
       module InstanceMethods
         # Disallowing destroying the object unless the frozen: false option was used.
         def before_destroy

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 = 69
+  MINOR = 70
 
   # 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.69.0
+  version: 5.70.0
 platform: ruby
 authors:
 - Jeremy Evans
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-06-01 00:00:00.000000000 Z
+date: 2023-07-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -202,6 +202,7 @@ extra_rdoc_files:
 - doc/release_notes/5.68.0.txt
 - doc/release_notes/5.69.0.txt
 - doc/release_notes/5.7.0.txt
+- doc/release_notes/5.70.0.txt
 - doc/release_notes/5.8.0.txt
 - doc/release_notes/5.9.0.txt
 files:
@@ -299,6 +300,7 @@ files:
 - doc/release_notes/5.68.0.txt
 - doc/release_notes/5.69.0.txt
 - doc/release_notes/5.7.0.txt
+- doc/release_notes/5.70.0.txt
 - doc/release_notes/5.8.0.txt
 - doc/release_notes/5.9.0.txt
 - doc/schema_modification.rdoc
@@ -365,6 +367,7 @@ files:
 - lib/sequel/connection_pool.rb
 - lib/sequel/connection_pool/sharded_single.rb
 - lib/sequel/connection_pool/sharded_threaded.rb
+- lib/sequel/connection_pool/sharded_timed_queue.rb
 - lib/sequel/connection_pool/single.rb
 - lib/sequel/connection_pool/threaded.rb
 - lib/sequel/connection_pool/timed_queue.rb