>|h hdZddlmZGddeZGddeZGddZGd d Zy ) a: SimplePooledDB - a very simple DB-API 2 database connection pool. Implements a pool of threadsafe cached DB-API 2 connections to a database which are transparently reused. This should result in a speedup for persistent applications such as the "Webware for Python" AppServer. For more information on the DB-API 2, see: https://www.python.org/dev/peps/pep-0249/ For more information on Webware for Python, see: https://webwareforpython.github.io/w4py/ Measures are taken to make the pool of connections threadsafe regardless of whether the DB-API 2 module used is threadsafe on the connection level (threadsafety > 1) or not. It must only be threadsafe on the module level (threadsafety = 1). If the DB-API 2 module is threadsafe, the connections will be shared between threads (keep this in mind if you use transactions). Usage: The idea behind SimplePooledDB is that it's completely transparent. After you have established your connection pool, stating the DB-API 2 module to be used, the number of connections to be cached in the pool and the connection parameters, e.g. import pgdb # import used DB-API 2 module from dbutils.simple_pooled_db import PooledDB dbpool = PooledDB(pgdb, 5, host=..., database=..., user=..., ...) you can demand database connections from that pool, db = dbpool.connection() and use them just as if they were ordinary DB-API 2 connections. It's really just a proxy class. db.close() will return the connection to the pool, it will not actually close it. This is so your existing code works nicely. Ideas for improvement: * Do not create the maximum number of connections on startup already, but only a certain number and the rest on demand. * Detect and transparently reset "bad" connections. * Connections should have some sort of maximum usage limit after which they should be automatically closed and reopened. * Prefer or enforce thread-affinity for the connections, allowing for both shareable and non-shareable connections. Please note that these and other ideas have been already implemented in in PooledDB, a more sophisticated version of SimplePooledDB. You might also consider using PersistentDB instead for thread-affine persistent database connections. SimplePooledDB may still serve as a very simple reference and example implementation for developers. Copyright, credits and license: * Contributed as MiscUtils/DBPool for Webware for Python by Dan Green, December 2000 * Thread safety bug found by Tom Schwaller * Fixes by Geoff Talvola (thread safety in _threadsafe_getConnection()) * Clean up by Chuck Esterbrook * Fix unthreadsafe functions which were leaking, Jay Love * Eli Green's webware-discuss comments were lifted for additional docs * Clean-up and detailed commenting, rename and move to DBUtils by Christoph Zwerschke in September 2005 Licensed under the MIT license. ) __version__ceZdZdZy) PooledDBErrorzGeneral PooledDB error.N__name__ __module__ __qualname____doc__W/var/www/html/test/engine/venv/lib/python3.12/site-packages/dbutils/simple_pooled_db.pyrrNs!r rceZdZdZy)NotSupportedErrorz(DB-API module not supported by PooledDB.Nrr r r rrRs2r rc(eZdZdZdZdZdZdZy)PooledDBConnectionzA proxy class for pooled database connections. You don't normally deal with this class directly, but use PooledDB to get new connections. c ||_||_y)zInitialize pooled connection.N)_con_pool)selfpoolcons r __init__zPooledDBConnection.__init__]s  r cv|j-|jj|jd|_yy)zClose the pooled connection.N)rrreturnConnectionrs r closezPooledDBConnection.closebs0 99 JJ ' ' 2DI !r c.t|j|S)z&Get the attribute with the given name.)getattrr)rnames r __getattr__zPooledDBConnection.__getattr__jstyy$''r c$|jy)zDelete the pooled connection.N)rrs r __del__zPooledDBConnection.__del__os  r N)rrr r rrr r"r r r rrVs  ( r rc>eZdZdZeZdZdZdZdZ dZ dZ dZ y ) PooledDBzA very simple database connection pool. After you have created the connection pool, you can get connections using getConnection(). c  |j}|dk(r td|dk(rGddlm}|||_|j |_|j|_ |j|_ nc|dvrTddl m }||_d|_g|_|j"|_|j$|_ |j&|_ n tdt)|D]#}|j|j*|i|%y#t$rd}YwxYw) a*Set up the database connection pool. dbapi: the DB-API 2 compliant module you want to use maxconnections: the number of connections cached in the pool args, kwargs: the parameters that shall be used to establish the database connections using connect() Nz8Database module does not support any level of threading.r)Queue))Lockz7Database module threading support cannot be determined.) threadsafety Exceptionrqueuer'_queue_unthreadsafe_get_connection connection_unthreadsafe_add_connection addConnection_unthreadsafe_return_connectionr threadingr*_lock_nextConnection _connections_threadsafe_get_connection_threadsafe_add_connection_threadsafe_return_connectionrangeconnect) rdbapimaxconnectionsargskwargsr+r'r*_is r rzPooledDB.__init__}s  --L 1 #JL L 1  $/DK"??DO!%!B!BD $($H$HD ! V # 'DJ#$D "D "==DO!%!@!@D $($F$FD !#IK K' ?B   }u}}d=f= > ?= L s C?? D  D cJt||jjS)Get a connection from the pool.)rr.getrs r r/z%PooledDB._unthreadsafe_get_connections!$ (9::r c:|jj|yzAdd a connection to the pool.N)r.putrrs r r1z%PooledDB._unthreadsafe_add_connections r c&|j|y)aReturn a connection to the pool. In this case, the connections need to be put back into the queue after they have been used. This is done automatically when the connection is closed and should never be called explicitly outside of this module. N)r1rHs r r3z(PooledDB._unthreadsafe_return_connections ))#.r c|j5|j}t||j|}|dz }|t |jk\rd}||_|cdddS#1swYyxYw)rCrr&N)r5r6rr7len)rnext_conrs r r8z#PooledDB._threadsafe_get_connectionsl ZZ ++H$T4+<+rRs?HT"I"3 3