"psycopg2.pool" – Connections pooling
*************************************

Creating new PostgreSQL connections can be an expensive operation.
This module offers a few pure Python classes implementing simple
connection pooling directly in the client application.

class psycopg2.pool.AbstractConnectionPool(minconn, maxconn, *args, **kwargs)

   Base class implementing generic key-based pooling code.

   New *minconn* connections are created automatically. The pool will
   support a maximum of about *maxconn* connections.  **args* and
   ***kwargs* are passed to the "connect()" function.

   The following methods are expected to be implemented by subclasses:

   getconn(key=None)

      Get a free connection from the pool.

      The *key* parameter is optional: if used, the connection will be
      associated to the key and calling "getconn()" with the same key
      again will return the same connection.

   putconn(conn, key=None, close=False)

      Put away a connection.

      If *close* is "True", discard the connection from the pool.
      *key* should be used consistently with "getconn()".

   closeall()

      Close all the connections handled by the pool.

      Note that all the connections are closed, including ones
      eventually in use by the application.

The following classes are "AbstractConnectionPool" subclasses ready to
be used.

class psycopg2.pool.SimpleConnectionPool(minconn, maxconn, *args, **kwargs)

   A connection pool that can’t be shared across different threads.

   Note: This pool class is useful only for single-threaded
     applications.

class psycopg2.pool.ThreadedConnectionPool(minconn, maxconn, *args, **kwargs)

   A connection pool that works with the threading module.

   Note: This pool class can be safely used in multi-threaded
     applications.

class psycopg2.pool.PersistentConnectionPool(minconn, maxconn, *args, **kwargs)

   A pool that assigns persistent connections to different threads.

   Note that this connection pool generates by itself the required
   keys using the current thread id.  This means that until a thread
   puts away a connection it will always get the same connection
   object by successive "getconn()" calls. This also means that a
   thread can’t use more than one single connection from the pool.

   Note: This pool class is mostly designed to interact with Zope
     and probably not useful in generic applications.
