class Sequel::ConnectionPool

The base connection pool class, which all other connection pools are based on. This class is not instantiated directly, but subclasses should at the very least implement the following API:

initialize(Database, Hash)

Initialize using the passed Sequel::Database object and options hash.

hold(Symbol, &block)

Yield a connection object (obtained from calling the block passed to initialize) to the current block. For sharded connection pools, the Symbol passed is the shard/server to use.

disconnect(Symbol)

Disconnect the connection object. For sharded connection pools, the Symbol passed is the shard/server to use.

servers

An array of shard/server symbols for all shards/servers that this connection pool recognizes.

size

an integer representing the total number of connections in the pool, or for the given shard/server if sharding is supported.

max_size

an integer representing the maximum size of the connection pool, or the maximum size per shard/server if sharding is supported.

For sharded connection pools, the sharded API adds the following methods:

add_servers(Array of Symbols)

start recognizing all shards/servers specified by the array of symbols.

remove_servers(Array of Symbols)

no longer recognize all shards/servers specified by the array of symbols.

Constants

OPTS
POOL_CLASS_MAP

Attributes

after_connect[RW]

The after_connect proc used for this pool. This is called with each new connection made, and is usually used to set custom per-connection settings.

connect_sqls[RW]

An array of sql strings to execute on each new connection.

db[RW]

The Sequel::Database object tied to this connection pool.

Public Class Methods

new(db, opts=OPTS) click to toggle source

Instantiates a connection pool with the given options. The block is called with a single symbol (specifying the server/shard to use) every time a new connection is needed. The following options are respected for all connection pools:

:after_connect

A callable object called after each new connection is made, with the connection object (and server argument if the callable accepts 2 arguments), useful for customizations that you want to apply to all connections.

:connect_sqls

An array of sql strings to execute on each new connection, after :after_connect runs.

:preconnect

Automatically create the maximum number of connections, so that they don't need to be created as needed. This is useful when connecting takes a long time and you want to avoid possible latency during runtime. Set to :concurrently to create the connections in separate threads. Otherwise they'll be created sequentially.

    # File lib/sequel/connection_pool.rb
 98 def initialize(db, opts=OPTS)
 99   @db = db
100   @after_connect = opts[:after_connect]
101   @connect_sqls = opts[:connect_sqls]
102   @error_classes = db.send(:database_error_classes).dup.freeze
103 end

Public Instance Methods

servers() click to toggle source

An array of symbols for all shards/servers, which is a single :default by default.

    # File lib/sequel/connection_pool.rb
106 def servers
107   [:default]
108 end

Private Instance Methods

disconnect_connection(conn) click to toggle source

Remove the connection from the pool. For threaded connections, this should be called without the mutex, because the disconnection may block.

    # File lib/sequel/connection_pool.rb
114 def disconnect_connection(conn)
115   db.disconnect_connection(conn)
116 end
disconnect_error?(exception) click to toggle source

Whether the given exception is a disconnect exception.

    # File lib/sequel/connection_pool.rb
119 def disconnect_error?(exception)
120   exception.is_a?(Sequel::DatabaseDisconnectError) || db.send(:disconnect_error?, exception, OPTS)
121 end
make_new(server) click to toggle source

Return a new connection by calling the connection proc with the given server name, and checking for connection errors.

    # File lib/sequel/connection_pool.rb
125 def make_new(server)
126   begin
127     conn = @db.connect(server)
128 
129     if ac = @after_connect
130       if ac.arity == 2
131         ac.call(conn, server)
132       else
133         ac.call(conn)
134       end
135     end
136 
137     if cs = @connect_sqls
138       cs.each do |sql|
139         db.send(:log_connection_execute, conn, sql)
140       end
141     end
142   rescue Exception=>exception
143     raise Sequel.convert_exception_class(exception, Sequel::DatabaseConnectionError)
144   end
145   raise(Sequel::DatabaseConnectionError, "Connection parameters not valid") unless conn
146   conn
147 end