o Rh/:@sddlZddlmZddlmZddlmZddlmZddl m Z ddl m Z m Z mZmZd d lmZmZd d ZGd ddZddZdS)N) ClauseElement) UpdateBase) DDLElement)exc)create_result_proxy)RootTransaction TransactionNestedTransactionTwoPhaseTransaction)_TransactionContextManager_SAConnectionContextManagercCs|SN)krrX/home/air/sanwanet/backup_V2/venv/lib/python3.10/site-packages/aiomysql/sa/connection.pynoopsrc@seZdZd8ddZddZddZdd Zd d Zd d Ze ddZ e ddZ ddZ ddZ ddZddZddZddZd8ddZd d!Zd"d#Zd8d$d%Zd&d'Zd(d)Zd*d+d,d-Zd*d+d.d/Ze d0d1Zd2d3Zd4d5Zd6d7ZdS)9 SAConnectionNcCs4||_d|_d|_t|_||_|j|_||_ dS)Nr) _connection _transaction_savepoint_seqweakrefWeakSet _weak_results_enginedialect_dialect_compiled_cache)self connectionenginecompiled_cacherrr__init__s  zSAConnection.__init__cOs |j|g|Ri|}t|S)a Executes a SQL query with optional parameters. query - a SQL query string or any sqlalchemy expression. *multiparams/**params - represent bound parameter values to be used in the execution. Typically, the format is a dictionary passed to *multiparams: await conn.execute( table.insert(), {"id":1, "value":"v1"}, ) ...or individual key/values interpreted by **params:: await conn.execute( table.insert(), id=1, value="v1" ) In the case that a plain SQL string is passed, a tuple or individual values in *multiparams may be passed:: await conn.execute( "INSERT INTO table (id, value) VALUES (%d, %s)", (1, "v1") ) await conn.execute( "INSERT INTO table (id, value) VALUES (%s, %s)", 1, "v1" ) Returns ResultProxy instance with results of SQL query execution. )_executer)rquery multiparamsparamscororrrexecutes%zSAConnection.executecst|rt|ttfr|rddt|jj|D}ntd|||j fddDg}|j |}|dS)z handle params cSsi|]\}}|j|qSr)key).0cpvalrrr Msz-SAConnection._base_params..z=Don't mix sqlalchemy SELECT clause with positional parameterscs"i|] }||t|qSr)getr)r+r*compiled_params processorsrrr.Vsr) isinstancelisttupleziptabler,r ArgumentErrorconstruct_params_bind_processorsrexecute_sequence_format)rr%dpcompiled is_updater'post_processed_paramsrr0r _base_paramsGs   zSAConnection._base_paramsc sd}t|tr|||IdHnAt|trtdt|trN|j|jd}g}t|t }|D] }| | ||||q1|t||IdH|j }ntdt |||j|IdH} |j| | S)z executemany N=Don't mix sqlalchemy DDL clause and execution with parametersrLsql statement should be str or SQLAlchemy data selection/modification clause)r3str executemanyrrr8rcompilerrappendr@_result_columnsrradd) rr%dpscursor result_mapr=r'r>r<retrrr _executemany]sD     zSAConnection._executemanyc sh|jIdH}t||}t|dkr||||IdHS|r$|d}d}t|tr7|||p1dIdHnjt|tr|j durh|}|j |}|sg|j |j d}|r]| |j ksb|sg|jsg||j |<n|j |j d}t|ts||||t|t} |j}n |rtd|} d}|t|| IdHntdt|||j |IdH} |j| | S)NrrrBrArC)rrK_distill_paramslenrNr3rDr)rrr/rFrkeysr'rr@rrHrr8r9rrrI) rr%r&r'rKr<rLr*r=r?rMrrrr$sV            zSAConnection._executecs.|j|g|Ri|IdH}|IdHS)z0Executes a SQL query and returns a scalar value.N)r)scalar)rr%r&r'resrrrrRszSAConnection.scalarcCs|jdup|jjS)zAThe readonly property that returns True if connections is closed.N)rclosedrrrrrTzSAConnection.closedcCs|jSr)rrUrrrr szSAConnection.connectioncCs|}t|S)a Begin a transaction and return a transaction handle. The returned object is an instance of Transaction. This object represents the "scope" of the transaction, which completes when either the .rollback or .commit method is called. Nested calls to .begin on the same SAConnection instance will return new Transaction objects that represent an emulated transaction within the scope of the enclosing transaction, that is:: trans = await conn.begin() # outermost transaction trans2 = await conn.begin() # "nested" await trans2.commit() # does nothing await trans.commit() # actually commits Calls to .commit only have an effect when invoked via the outermost Transaction object, though the .rollback method of any of the Transaction objects will roll back the transaction. See also: .begin_nested - use a SAVEPOINT .begin_twophase - use a two phase/XA transaction )_beginr )rr(rrrbeginszSAConnection.begincs6|jdurt||_|IdH|jSt||jSr)rr _begin_implr rUrrrrWs    zSAConnection._begincsH|jIdH}z|dIdHW|IdHdS|IdHw)NBEGIN)rrKr)closercurrrrrYs "zSAConnection._begin_implcT|jIdH}z|dIdHW|IdHd|_dS|IdHd|_w)NCOMMITrrKr)r[rr\rrr _commit_impl zSAConnection._commit_implcr^)NROLLBACKr`r\rrr_rollback_implrbzSAConnection._rollback_implcsP|jdurt||_|IdH|jSt||j|_|IdH|j_|jS)aBegin a nested transaction and return a transaction handle. The returned object is an instance of :class:`.NestedTransaction`. Nested transactions require SAVEPOINT support in the underlying database. Any transaction in the hierarchy may .commit() and .rollback(), however the outermost transaction still controls the overall .commit() or .rollback() of the transaction of a whole. N)rrrYr _savepoint_impl _savepointrUrrr begin_nesteds zSAConnection.begin_nestedcsd|jd7_d|j}|jIdH}z|d|IdH|W|IdHS|IdHw)Nrzaiomysql_sa_savepoint_%sz SAVEPOINT )rrrKr)r[)rnamer]rrrres  zSAConnection._savepoint_implcT|jIdH}z|d|IdHW|IdHn|IdHw||_dS)NzROLLBACK TO SAVEPOINT r`rrhparentr]rrr_rollback_to_savepoint_impl"   z(SAConnection._rollback_to_savepoint_implcri)NzRELEASE SAVEPOINT r`rjrrr_release_savepoint_impl*rmz$SAConnection._release_savepoint_implcsL|jdur td|dur|j}t|||_|d|IdH|jS)aBegin a two-phase or XA transaction and return a transaction handle. The returned object is an instance of TwoPhaseTransaction, which in addition to the methods provided by Transaction, also provides a TwoPhaseTransaction.prepare() method. xid - the two phase transaction id. If not supplied, a random id will be generated. NzOCannot start a two phase transaction when a transaction is already in progress.z XA START %s)rrInvalidRequestErrorr create_xidr r)rxidrrrbegin_twophase2s   zSAConnection.begin_twophasecs.|d|IdH|d|IdHdS)N XA END '%s'zXA PREPARE '%s'r)rqrrr_prepare_twophase_implIsz#SAConnection._prepare_twophase_implcs |dIdH}dd|DS)z3Return a list of prepared twophase transaction ids.z XA RECOVER;NcSsg|]}|dqS)rr)r+rowrrr Psz1SAConnection.recover_twophase..ru)rresultrrrrecover_twophaseMszSAConnection.recover_twophaseT) is_preparedc2|s |d|IdH|d|IdHdS)z'Rollback prepared twophase transaction.rtNzXA ROLLBACK '%s'rurrrr{rrrrollback_preparedRzSAConnection.rollback_preparedcr|)z%Commit prepared twophase transaction.rtNzXA COMMIT '%s'rur}rrrcommit_preparedXrzSAConnection.commit_preparedcCs|jduo|jjS)z,Return True if a transaction is in progress.N)r is_activerUrrrin_transaction^rVzSAConnection.in_transactioncsL|jdurdS|jdur|jIdHd|_|j|d|_d|_dS)aoClose this SAConnection. This results in a release of the underlying database resources, that is, the underlying connection referenced internally. The underlying connection is typically restored back to the connection-holding Pool referenced by the Engine that produced this SAConnection. Any transactional state present on the underlying connection is also unconditionally released via calling Transaction.rollback() method. After .close() is called, the SAConnection is permanently in a closed state, and will allow no further operations. N)rrrollbackrreleaserUrrrr[cs    zSAConnection.closecs|SrrrUrrr __aenter__}szSAConnection.__aenter__cs|IdHdSr)r[)rexc_typeexc_valexc_tbrrr __aexit__szSAConnection.__aexit__r)__name__ __module__ __qualname__r#r)r@rNr$rRpropertyrTr rXrWrYrardrgrerlrnrsrvrzr~rrr[rrrrrrrs<  (*2       rcCs|s |r|gSgSt|dkr;|d}t|ttfr/|r*t|ddr,t|dds,|S|gSt|dr7|gS|ggSt|ddrKt|ddsK|S|gS)a Given arguments from the calling form *multiparams, **params, return a list of bind parameter structures, usually a list of dictionaries. In the case of 'raw' execution which accepts positional parameters, it may be a list of tuples or lists. rr__iter__striprQ)rPr3r4r5hasattr)r&r'zerorrrrOs(     rO)rsqlalchemy.sqlrsqlalchemy.sql.dmlrsqlalchemy.sql.ddlrrryr transactionrr r r utilsr rrrrOrrrrs      r