>|h"-dZddlmZddlmZmZmZddlmZddl m Z dZ dZ Gdd e ZGd d eZGd d eZeZeZGddZGddZy)aAPooledPg - pooling for classic PyGreSQL connections. Implements a pool of steady, thread-safe cached connections to a PostgreSQL database which are transparently reused, using the classic (not DB-API 2 compliant) PyGreSQL API. This should result in a speedup for persistent applications such as the application server of "Webware for Python," without loss of robustness. Robustness is provided by using "hardened" SteadyPg connections. Even if the underlying database is restarted and all connections are lost, they will be automatically and transparently reopened. However, since you don't want this to happen in the middle of a database transaction, you must explicitly start transactions with the begin() method so that SteadyPg knows that the underlying connection shall not be replaced and errors passed on until the transaction is completed. Measures are taken to make the pool of connections thread-safe regardless of the fact that the classic PyGreSQL pg module itself is not thread-safe at the connection level. For more information on PostgreSQL, see: https://www.postgresql.org/ For more information on PyGreSQL, see: http://www.pygresql.org For more information on Webware for Python, see: https://webwareforpython.github.io/w4py/ Usage: First you need to set up the database connection pool by creating an instance of PooledPg, passing the following parameters: mincached: the initial number of connections in the pool (the default of 0 means no connections are made at startup) maxcached: the maximum number of connections in the pool (the default value of 0 or None means unlimited pool size) maxconnections: maximum number of connections generally allowed (the default value of 0 or None means any number of connections) blocking: determines behavior when exceeding the maximum (if this is set to true, block and wait until the number of connections decreases, but by default an error will be reported) maxusage: maximum number of reuses of a single connection (the default of 0 or None means unlimited reuse) When this maximum usage number of the connection is reached, the connection is automatically reset (closed and reopened). setsession: an optional list of SQL commands that may serve to prepare the session, e.g. ["set datestyle to german", ...] Additionally, you have to pass the parameters for the actual PostgreSQL connection which are passed via PyGreSQL, such as the names of the host, database, user, password etc. For instance, if you want a pool of at least five connections to your local database 'mydb': from dbutils.pooled_pg import PooledPg pool = PooledPg(5, dbname='mydb') Once you have set up the connection pool you can request database connections from that pool: db = pool.connection() You can use these connections just as if they were ordinary classic PyGreSQL API connections. Actually what you get is a proxy class for the hardened SteadyPg version of the connection. The connection will not be shared with other threads. If you don't need it anymore, you should immediately return it to the pool with db.close(). You can get another connection in the same way or with db.reopen(). Warning: In a threaded environment, never do the following: res = pool.connection().query(...).getresult() This would release the connection too early for reuse which may be fatal because the connections are not thread-safe. Make sure that the connection object stays alive as long as you are using it, like that: db = pool.connection() res = db.query(...).getresult() db.close() # or del db You can also a context manager for simpler code: with pool.connection() as db: res = db.query(...).getresult() Note that you need to explicitly start transactions by calling the begin() method. This ensures that the transparent reopening will be suspended until the end of the transaction, and that the connection will be rolled back before being given back to the connection pool. To end transactions, use one of the end(), commit() or rollback() methods. Ideas for improvement: * Add a thread for monitoring, restarting (or closing) bad or expired connections (similar to DBConnectionPool/ResourcePool by Warren Smith). * Optionally log usage, bad connections and exceeding of limits. Copyright, credits and license: * Contributed as supplement for Webware for Python and PyGreSQL by Christoph Zwerschke in September 2005 * Based on the code of DBPool, contributed to Webware for Python by Dan Green in December 2000 Licensed under the MIT license. )suppress)EmptyFullQueue) __version__)SteadyPgConnectionceZdZdZy) PooledPgErrorzGeneral PooledPg error.N__name__ __module__ __qualname____doc__P/var/www/html/test/engine/venv/lib/python3.12/site-packages/dbutils/pooled_pg.pyr r ~s!rr ceZdZdZy)InvalidConnectionErrorzDatabase connection is invalid.Nr rrrrrs)rrceZdZdZy)TooManyConnectionsErrorz*Too many database connections were opened.Nr rrrrrs4rrc@eZdZdZeZ d dZdZdZdZ dZ dZ y) PooledPgzPool for classic PyGreSQL connections. After you have created the connection pool, you can use connection() to get pooled, steady PostgreSQL connections. Nc|| c|_|_||_||_|xsd|_|d}|d}|d}|r||kr|}|r"||kr|}ddlm} | ||_||_nd|_t||_ t|D cgc]} |j} } | r"| jj| r!yycc} w)acSet up the PostgreSQL connection pool. mincached: initial number of connections in the pool (0 means no connections are made at startup) maxcached: maximum number of connections in the pool (0 or None means unlimited pool size) maxconnections: maximum number of connections generally allowed (0 or None means an arbitrary number of connections) blocking: determines behavior when exceeding the maximum (if this is set to true, block and wait until the number of connections decreases, otherwise an error will be reported) maxusage: maximum number of reuses of a single connection (0 or None means unlimited reuse) When this maximum usage number of the connection is reached, the connection is automatically reset (closed and reopened). setsession: optional list of SQL commands that may serve to prepare the session, e.g. ["set datestyle to ...", "set time zone ..."] reset: how connections should be reset when returned to the pool (0 or None to rollback transactions started with begin(), 1 to always issue a rollback, 2 for a complete reset) args, kwargs: the parameters that shall be used to establish the PostgreSQL connections using class PyGreSQL pg.DB() rN) Semaphore)_args_kwargs _maxusage _setsession_reset threadingr _connections _blockingr_cacherange connectionpopclose) self mincached maxcachedmaxconnectionsblockingmaxusage setsessionresetargskwargsriidles r__init__zPooledPg.__init__s8$(  DL!%jq  I  I  !N Y.!I  )!* + ). 9D %DN $D I& +0+;%>t~~%N) ) +++((*C"$,, +((*C +sAA;:A;c |jtk(r|jnG|jtk(s |jr(t t 5|jddd|jj||jr|jjyy#1swYLxYw#t$r|jYOwxYw)z*Put a connection back into the pool cache.N)r!RESET_COMPLETELYr1RESET_ALWAYS_ROLLBACK _transactionr Exceptionrollbackr% put_nowaitrr)r#releaser>s rcachezPooledPg.caches {{..  559I9Ii(#LLN# KK " "3 '       % % '  ##  IIK s*AB<B0%#B<0B95B<<CCc |jj}tt5|j ddd|j r|j j j#1swY0xYw#t$rYywxYw)z"Close all connections in the pool.N)r%r<rrDr)r#rGrr>s rr)zPooledPg.closesu kk,,.i( IIK $$%%--/     s')A8A,.A8,A51A88 BBc4 |jy#YyxYw)zDelete the pool.Nr)r8s r__del__zPooledPg.__del__  JJL  )rrrFNNN) rrrrrversionr6r9r'rHr)rLrrrrrs8 G*+',265n? - ( rrc:eZdZdZdZdZdZdZdZdZ dZ y ) r=z.Proxy class for pooled PostgreSQL connections.c ||_||_y)zCreate a pooled DB-API 2 connection. pool: the corresponding PooledPg instance con: the underlying SteadyPg connection N)_pool_con)r*poolr?s rr6zPooledPgConnection.__init__s   rcv|jr-|jj|jd|_yy)zClose the pooled connection.N)rSrRrHr8s rr)zPooledPgConnection.closes- 99 JJ  TYY 'DI rc|jr|jjy|jj|_y)zReopen the pooled connection.N)rSreopenrRr'r8s rrWzPooledPgConnection.reopens/ 99 II    --/DIrcR|jrt|j|St)zProxy all members of the class.)rSgetattrr)r*names r __getattr__zPooledPgConnection.__getattr__!s 99499d+ +$$rc4 |jy#YyxYw)zDelete the pooled connection.NrKr8s rrLzPooledPgConnection.__del__'rMrNc|S)z+Enter a runtime context for the connection.rr8s r __enter__zPooledPgConnection.__enter__/s rc$|jy)z*Exit a runtime context for the connection.NrK)r*excs r__exit__zPooledPgConnection.__exit__3s  rN) rrrrr6r)rWr[rLr^rarrrr=r=s(80% rr=N)r contextlibrqueuerrrr steady_pgr rBrArDr rrInvalidConnectionTooManyConnectionsrr=rrrrhstpd $$)"I"*]*5m5 +,ooh22r