Class | Sequel::ThreadedConnectionPool
In: | lib/sequel/connection_pool/threaded.rb
Parent: | Sequel::ConnectionPool

A connection pool allowing multi-threaded access to a pool of connections. This is the default connection pool used by Sequel.

### Methods

disconnect hold new size

### External Aliases

make_new | -> | default_make_new
| Alias the default make_new method, so subclasses can call it directly.

### Attributes

allocated | [R] | A hash with thread keys and connection values for currently allocated connections.
available_connections | [R] | An array of connections that are available for use by the pool.
max_size | [R] | The maximum number of connections this pool will create (per shard/server if sharding).

### Public Class methods

new(opts = {}, &block)

The following additional options are respected:

- :max_connections - The maximum number of connections the connection pool will open (default 4)
- :pool_sleep_time - The amount of time to sleep before attempting to acquire a connection again (default 0.001)
- :pool_timeout - The amount of seconds to wait to acquire a connection before raising a PoolTimeoutError (default 5)

[Source]

        # File lib/sequel/connection_pool/threaded.rb, line 22
    22:   def initialize(opts = {}, &block)
    23:     super
    24:     @max_size = Integer(opts[:max_connections] || 4)
    25:     raise(Sequel::Error, ':max_connections must be positive') if @max_size < 1
    26:     @mutex = Mutex.new
    27:     @available_connections = []
    28:     @allocated = {}
    29:     @timeout = Integer(opts[:pool_timeout] || 5)
    30:     @sleep_time = Float(opts[:pool_sleep_time] || 0.001)
    31:   end

### Public Instance methods

disconnect(opts={}, &block)

Removes all connections currently available on all servers, optionally yielding each connection to the given block. 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.

[Source]

        # File lib/sequel/connection_pool/threaded.rb, line 46
    46:   def disconnect(opts={}, &block)
    47:     block ||= @disconnection_proc
    48:     sync do
    49:       @available_connections.each{|conn| block.call(conn)} if block
    50:       @available_connections.clear
    51:     end
    52:   end

hold(server=nil) {|conn| ...}

Chooses the first available connection to the given server, or if none are available, creates a new connection. Passes the connection to the supplied block:

      pool.hold {|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.

[Source]

        # File lib/sequel/connection_pool/threaded.rb, line 68
    68:   def hold(server=nil)
    69:     t = Thread.current
    70:     if conn = owned_connection(t)
    71:       return yield(conn)
    72:     end
    73:     begin
    74:       unless conn = acquire(t)
    75:         time = Time.now
    76:         timeout = time + @timeout
    77:         sleep_time = @sleep_time
    78:         sleep sleep_time
    79:         until conn = acquire(t)
    80:           raise(::Sequel::PoolTimeout) if Time.now > timeout
    81:           sleep sleep_time
    82:         end
    83:       end
    84:       yield conn
    85:     rescue Sequel::DatabaseDisconnectError
    86:       oconn = conn
    87:       conn = nil
    88:       @disconnection_proc.call(oconn) if @disconnection_proc && oconn
    89:       @allocated.delete(t)
    90:       raise
    91:     ensure
    92:       sync{release(t)} if conn
    93:     end
    94:   end

size()

The total number of connections opened for the given server, should be equal to available_connections.length + allocated.length.

[Source]

        # File lib/sequel/connection_pool/threaded.rb, line 35
    35:   def size
    36:     @allocated.length + @available_connections.length
    37:   end

[Validate]