sequel 5.68.0 → 5.70.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e682467c455e044847fffb313b6d8a669e0dc89ca8ea330468841de642b84227
-  data.tar.gz: cd0687fd059a6b6d38cb31279d5cdacccd4a0a309f1155171f12551d43eacb0b
+  metadata.gz: 780e8bd3203a4aa27f70c94dd2ddd29e28826ec7b74b86296a2571d40ff2a74a
+  data.tar.gz: f600cfad2e5401f2c1150838ecacac0cd34ba38da4a69bd3afd580dbadaee35f
 SHA512:
-  metadata.gz: 3c16f027251aa67e04cab0973a57da21682e083c7362f37bdbf84937266ca6878e200fb7c44a0583b8ac6fab62d1fd4b55744929760fc63a9d1f850452db5df6
-  data.tar.gz: 60eee01297c47ee9c18ae76b6974b6eb3e492e58c7f408ee9c32476f1ae0ae5848ffc47cb80889f7070b02088e7e66509b64e460a1ef61c90ffb5a59da6a3c09
+  metadata.gz: b22192e34739b2158a543f18f51b52b44063b86b02c6968a8f8e1ff2deec8338fa4f81176a4f5f2b27ace6fcefe9d3511ccaa73c43e2b660743a3a736f303080
+  data.tar.gz: 4540e3f53f53d6fe8b7a22212ab7d6678502e87bf67a5081c22d1da02ea8ea2090589e384fe17e4ca454c0c4c45358f1aaed1772d27e7732f7f68071e5914ea6

data/CHANGELOG

@@ -1,3 +1,29 @@
+=== 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)
+
+* Make mysql adapter work with ruby-mysql 4+ (jeremyevans)
+
+* Add Model::DatasetModule#model accessor (davekaro) (#2040)
+
+* Add trilogy adapter (jeremyevans)
+
 === 5.68.0 (2023-05-01)
 
 * Add validation_helpers_generic_type_messages plugin for more useful type validation failure messages (jeremyevans) (#2028)

data/README.rdoc

@@ -13,7 +13,7 @@ toolkit for Ruby.
   database sharding.
 * Sequel currently has adapters for ADO, Amalgalite, 
   IBM_DB, JDBC, MySQL, Mysql2, ODBC, Oracle,
-  PostgreSQL, SQLAnywhere, SQLite3, and TinyTDS.
+  PostgreSQL, SQLAnywhere, SQLite3, TinyTDS, and Trilogy.
 
 == Resources
 

data/doc/opening_databases.rdoc

@@ -279,7 +279,7 @@ if either the :sslca or :sslkey option is given.
 
 === mysql2
 
-This is a newer MySQL adapter that does typecasting in C, so it is often faster than the
+This is a MySQL adapter that does typecasting in C, so it is often faster than the
 mysql adapter.  The options given are passed to Mysql2::Client.new, see the mysql2 documentation
 for details on what options are supported. The :timeout, :auto_is_null, :sql_mode, and :disable_split_materialized
 options supported by the mysql adapter are also supported for mysql2 adapter (and any other adapters connecting to
@@ -423,3 +423,10 @@ Other Sequel specific options:
              This should be specified as an integer.  If you plan on setting large
              text or blob values via tinytds, you should use this option or modify
              your freetds.conf file.
+
+=== trilogy
+
+This is a MySQL adapter that does typecasting in C, and does not require any mysql client libraries installed.
+The options given are passed to Trilogy.new, see the trilogy documentation for details on what options are
+supported. The :timeout, :auto_is_null, :sql_mode, and :disable_split_materialized
+options supported by the mysql adapter are also supported for trilogy adapter.

data/doc/release_notes/5.69.0.txt

@@ -0,0 +1,26 @@
+= New Features
+
+* An adapter has been added for the trilogy MySQL driver. One large
+  advantage over mysql2 is that trilogy does not require any MySQL
+  client libraries installed on the machine. The trilogy adapter
+  has basically the same issues/skipped specs as the mysql2 adapter,
+  but it also does not support an application_timezone different
+  than the database_timezone.
+
+* Model dataset modules now have a model accessor, allowing for
+  code such as:
+
+    class Foo < Sequel::Model
+      dataset_module do
+        where :kept, Sequel[model.table_name][:discarded_at] => nil
+      end
+    end
+
+= Improvements
+
+* The mysql adapter now works with ruby-mysql 4 (the pure-ruby
+  MySQL driver).  Note that multi-results support does not work
+  with ruby-mysql 4 (it doesn't work with mysql2, trilogy, or
+  other Sequel adapters in general).
+
+* Warnings for unsupported flags are now avoided on ruby-mysql 3.

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/doc/sharding.rdoc

@@ -39,7 +39,9 @@ is the simplest configuration:
     servers: {read_only: {host: 'replica_server'}})
 
 This will use the replica_server for SELECT queries and primary_server for
-other queries.
+other queries. The :read_only key in the :servers hash is special in that
+it sets the default database for Dataset methods that use SELECT queries
+(which are generally read queries that do not modify the database).
 
 If you want to ensure your queries are going to a specific database, you
 can force this for a given query by using the .server method and passing 

data/lib/sequel/adapters/mysql.rb

@@ -29,6 +29,21 @@ module Sequel
     end
     MYSQL_TYPES.freeze
 
+    RUBY_MYSQL_3 = !Mysql.respond_to?(:init)
+    RUBY_MYSQL_4 = RUBY_MYSQL_3 && ::Mysql::VERSION.to_i >= 4
+
+    if RUBY_MYSQL_3
+      class Adapter < ::Mysql
+        alias real_connect connect
+        alias use_result store_result
+        if RUBY_MYSQL_4
+          def initialize(**opts)
+            super(**opts.merge(:cast=>false))
+          end
+        end
+      end
+    end
+
     class Database < Sequel::Database
       include Sequel::MySQL::DatabaseMethods
       include Sequel::MySQL::MysqlMysql2::DatabaseMethods
@@ -72,7 +87,7 @@ module Sequel
       def connect(server)
         opts = server_opts(server)
 
-        if Mysql.respond_to?(:init)
+        if !RUBY_MYSQL_3
           conn = Mysql.init
           conn.options(Mysql::READ_DEFAULT_GROUP, opts[:config_default_group] || "client")
           conn.options(Mysql::OPT_LOCAL_INFILE, opts[:config_local_infile]) if opts.has_key?(:config_local_infile)
@@ -88,8 +103,8 @@ module Sequel
             conn.options(Mysql::OPT_CONNECT_TIMEOUT, connect_timeout)
           end
         else
-          # ruby-mysql 3 API
-          conn = Mysql.new
+          # ruby-mysql 3+ API
+          conn = Adapter.new
           # no support for default group
           conn.local_infile = opts[:config_local_infile] if opts.has_key?(:config_local_infile)
           if encoding = opts[:encoding] || opts[:charset]
@@ -101,10 +116,7 @@ module Sequel
           if connect_timeout = opts[:connect_timeout]
             conn.connect_timeout = connect_timeout
           end
-          conn.singleton_class.class_eval do
-            alias real_connect connect
-            alias use_result store_result
-          end
+          opts[:compress] = false
         end
 
         conn.ssl_set(opts[:sslkey], opts[:sslcert], opts[:sslca], opts[:sslcapath], opts[:sslcipher]) if opts[:sslca] || opts[:sslkey]

data/lib/sequel/adapters/trilogy.rb

@@ -0,0 +1,117 @@
+# frozen-string-literal: true
+
+require 'trilogy'
+require_relative 'shared/mysql'
+
+module Sequel
+  module Trilogy
+    class Database < Sequel::Database
+      include Sequel::MySQL::DatabaseMethods
+
+      QUERY_FLAGS = ::Trilogy::QUERY_FLAGS_CAST | ::Trilogy::QUERY_FLAGS_CAST_BOOLEANS
+      LOCAL_TIME_QUERY_FLAGS = QUERY_FLAGS | ::Trilogy::QUERY_FLAGS_LOCAL_TIMEZONE
+
+      set_adapter_scheme :trilogy
+      
+      # Connect to the database.  See Trilogy documentation for options.
+      def connect(server)
+        opts = server_opts(server)
+        opts[:username] ||= opts.delete(:user)
+        opts[:found_rows] = true
+        conn = ::Trilogy.new(opts)
+        mysql_connection_setting_sqls.each{|sql| log_connection_yield(sql, conn){conn.query(sql)}}
+        conn
+      end
+
+      def disconnect_connection(c)
+        c.discard!
+      rescue ::Trilogy::Error
+        nil
+      end
+
+      # Execute the given SQL on the given connection and yield the result.
+      def execute(sql, opts)
+        r = synchronize(opts[:server]) do |conn|
+          log_connection_yield((log_sql = opts[:log_sql]) ? sql + log_sql : sql, conn) do
+            conn.query_with_flags(sql, timezone.nil? || timezone == :local ? LOCAL_TIME_QUERY_FLAGS : QUERY_FLAGS)
+          end
+        end
+        yield r
+      rescue ::Trilogy::Error => e
+        raise_error(e)
+      end
+
+      def execute_dui(sql, opts=OPTS)
+        execute(sql, opts, &:affected_rows)
+      end
+
+      def execute_insert(sql, opts=OPTS)
+        execute(sql, opts, &:last_insert_id)
+      end
+
+      def freeze
+        server_version
+        super
+      end
+
+      # Return the version of the MySQL server to which we are connecting.
+      def server_version(_server=nil)
+        @server_version ||= super()
+      end
+
+      private
+
+      def database_specific_error_class(exception, opts)
+        case exception.message
+        when /1205 - Lock wait timeout exceeded; try restarting transaction\z/
+          DatabaseLockTimeout
+        else
+          super
+        end
+      end
+
+      def connection_execute_method
+        :query
+      end
+
+      def database_error_classes
+        [::Trilogy::Error]
+      end
+
+      def dataset_class_default
+        Dataset
+      end
+
+      # Convert tinyint(1) type to boolean if convert_tinyint_to_bool is true
+      def schema_column_type(db_type)
+        db_type =~ /\Atinyint\(1\)/ ? :boolean : super
+      end
+    end
+
+    class Dataset < Sequel::Dataset
+      include Sequel::MySQL::DatasetMethods
+
+      def fetch_rows(sql)
+        execute(sql) do |r|
+          self.columns = r.fields.map!{|c| output_identifier(c.to_s)}
+          r.each_hash{|h| yield h}
+        end
+        self
+      end
+      
+      private
+
+      def execute(sql, opts=OPTS)
+        opts = Hash[opts]
+        opts[:type] = :select
+        super
+      end
+
+      # Handle correct quoting of strings using ::Trilogy#escape.
+      def literal_string_append(sql, v)
+        sql << "'" << db.synchronize(@opts[:server]){|c| c.escape(v)} << "'"
+      end
+    end
+  end
+end
+

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/database/connecting.rb

@@ -8,7 +8,7 @@ module Sequel
     # ---------------------
 
     # Array of supported database adapters
-    ADAPTERS = %w'ado amalgalite ibmdb jdbc mock mysql mysql2 odbc oracle postgres sqlanywhere sqlite tinytds'.map(&:to_sym)
+    ADAPTERS = %w'ado amalgalite ibmdb jdbc mock mysql mysql2 odbc oracle postgres sqlanywhere sqlite tinytds trilogy'.map(&:to_sym)
 
     # The Database subclass for the given adapter scheme.
     # Raises Sequel::AdapterNotFound if the adapter

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/model/dataset_module.rb

@@ -8,6 +8,9 @@ module Sequel
     # automatically creates class methods for public dataset
     # methods.
     class DatasetModule < Dataset::DatasetModule
+      # The model class related to this dataset module.
+      attr_reader :model
+
       # Store the model related to this dataset module.
       def initialize(model)
         @model = model

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 = 68
+  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.68.0
+  version: 5.70.0
 platform: ruby
 authors:
 - Jeremy Evans
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-05-01 00:00:00.000000000 Z
+date: 2023-07-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -200,7 +200,9 @@ extra_rdoc_files:
 - doc/release_notes/5.66.0.txt
 - doc/release_notes/5.67.0.txt
 - 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:
@@ -296,7 +298,9 @@ files:
 - doc/release_notes/5.66.0.txt
 - doc/release_notes/5.67.0.txt
 - 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
@@ -349,6 +353,7 @@ files:
 - lib/sequel/adapters/sqlanywhere.rb
 - lib/sequel/adapters/sqlite.rb
 - lib/sequel/adapters/tinytds.rb
+- lib/sequel/adapters/trilogy.rb
 - lib/sequel/adapters/utils/columns_limit_1.rb
 - lib/sequel/adapters/utils/emulate_offset_with_reverse_and_count.rb
 - lib/sequel/adapters/utils/emulate_offset_with_row_number.rb
@@ -362,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