ó ù¢TQc@sOdZddlmZddlmZmZdefd„ƒYZdd„Z e dd„Z dd„Z dd „Z dd „Zdd „Zdd „Zdd „Ze dd„Zdd„Zdd„Zdd„Zdd„Zdd„Zdd„Zdd„Zdefd„ƒYZd„Zdd„Zdd„Zdd„ZdS(s+ This module implements a transaction manager that can be used to define transaction handling in a request or view function. It is used by transaction control middleware and decorators. The transaction manager can be in managed or in auto state. Auto state means the system is using a commit-on-save strategy (actually it's more like commit-on-change). As soon as the .save() or .delete() (or related) methods are called, a commit is made. Managed transactions don't do those commits, but will need some kind of manual or implicit commits or rollbacks. iÿÿÿÿ(twraps(t connectionstDEFAULT_DB_ALIAStTransactionManagementErrorcBseZdZRS(s^ This exception is thrown when something bad happens with transaction management. (t__name__t __module__t__doc__(((s.../Django//lib/python/django/db/transaction.pyRscCs-|dkrt}nt|}|jƒdS(sz Roll back any ongoing transactions and clean the transaction management state of the connection. This method is to be used only in cases where using balanced leave_transaction_management() calls isn't possible. For example after a request has finished, the transaction state isn't known, yet the connection must be cleaned up for the next request. N(tNoneRRtabort(tusingt connection((s.../Django//lib/python/django/db/transaction.pyRs   cCs0|dkrt}nt|}|j|ƒdS(s‚ Enters transaction management for a running thread. It must be balanced with the appropriate leave_transaction_management call, since the actual state is managed as a stack. The state and dirty flag are carried over from the surrounding block or from the settings, if there is no surrounding block (dirty is always false when no current block is running). N(RRRtenter_transaction_management(tmanagedR R ((s.../Django//lib/python/django/db/transaction.pyR *s   cCs-|dkrt}nt|}|jƒdS(sÝ Leaves transaction management for a running thread. A dirty flag is carried over to the surrounding block, as a commit will commit all changes, even those from outside. (Commits are on connection level.) N(RRRtleave_transaction_management(R R ((s.../Django//lib/python/django/db/transaction.pyR 9s   cCs)|dkrt}nt|}|jƒS(s^ Returns True if the current transaction requires a commit for changes to happen. N(RRRtis_dirty(R R ((s.../Django//lib/python/django/db/transaction.pyRDs   cCs-|dkrt}nt|}|jƒdS(s¾ Sets a dirty flag for the current thread and code streak. This can be used to decide in a managed block of code to decide whether there are open changes waiting for commit. N(RRRt set_dirty(R R ((s.../Django//lib/python/django/db/transaction.pyRNs   cCs-|dkrt}nt|}|jƒdS(s¹ Resets a dirty flag for the current thread and code streak. This can be used to decide in a managed block of code to decide whether a commit or rollback should happen. N(RRRt set_clean(R R ((s.../Django//lib/python/django/db/transaction.pyRYs   cCs-|dkrt}nt|}|jƒdS(N(RRRtclean_savepoints(R R ((s.../Django//lib/python/django/db/transaction.pyRds   cCs)|dkrt}nt|}|jƒS(sO Checks whether the transaction manager is in manual or in auto state. N(RRRt is_managed(R R ((s.../Django//lib/python/django/db/transaction.pyRjs   cCs0|dkrt}nt|}|j|ƒdS(sõ Puts the transaction manager into a manual state: managed transactions have to be committed explicitly by the user. If you switch off transaction management and there is a pending commit/rollback, the data will be commited. N(RRRR (tflagR R ((s.../Django//lib/python/django/db/transaction.pyR ss   cCs-|dkrt}nt|}|jƒdS(sK Commits changes if the system is not in managed transaction mode. N(RRRtcommit_unless_managed(R R ((s.../Django//lib/python/django/db/transaction.pyRs   cCs-|dkrt}nt|}|jƒdS(sN Rolls back changes if the system is not in managed transaction mode. N(RRRtrollback_unless_managed(R R ((s.../Django//lib/python/django/db/transaction.pyRˆs   cCs-|dkrt}nt|}|jƒdS(s; Does the commit itself and resets the dirty flag. N(RRRtcommit(R R ((s.../Django//lib/python/django/db/transaction.pyR‘s   cCs-|dkrt}nt|}|jƒdS(sK This function does the rollback itself and resets the dirty flag. N(RRRtrollback(R R ((s.../Django//lib/python/django/db/transaction.pyRšs   cCs)|dkrt}nt|}|jƒS(sÑ Creates a savepoint (if supported and required by the backend) inside the current transaction. Returns an identifier for the savepoint that will be used for the subsequent rollback or commit. N(RRRt savepoint(R R ((s.../Django//lib/python/django/db/transaction.pyR£s   cCs0|dkrt}nt|}|j|ƒdS(sq Rolls back the most recent savepoint (if one exists). Does nothing if savepoints are not supported. N(RRRtsavepoint_rollback(tsidR R ((s.../Django//lib/python/django/db/transaction.pyR®s   cCs0|dkrt}nt|}|j|ƒdS(sn Commits the most recent savepoint (if one exists). Does nothing if savepoints are not supported. N(RRRtsavepoint_commit(RR R ((s.../Django//lib/python/django/db/transaction.pyR¸s   t TransactioncBs2eZdZd„Zd„Zd„Zd„ZRS(s¯ Acts as either a decorator, or a context manager. If it's a decorator it takes a function and returns a wrapped function. If it's a contextmanager it's used with the ``with`` statement. In either event entering/exiting are called before and after, respectively, the function/block is executed. autocommit, commit_on_success, and commit_manually contain the implementations of entering and exiting. cCs||_||_||_dS(N(tenteringtexitingR (tselfRRR ((s.../Django//lib/python/django/db/transaction.pyt__init__Ðs  cCs|j|jƒdS(N(RR (R((s.../Django//lib/python/django/db/transaction.pyt __enter__ÕscCs|j||jƒdS(N(RR (Rtexc_typet exc_valuet traceback((s.../Django//lib/python/django/db/transaction.pyt__exit__Øscs"tˆƒ‡‡fd†ƒ}|S(Ncsˆˆ||ŽSWdQXdS(N((targstkwargs(Rtfunc(s.../Django//lib/python/django/db/transaction.pytinnerÜs(R(RR(R)((RR(s.../Django//lib/python/django/db/transaction.pyt__call__Ûs(RRRR R!R%R*(((s.../Django//lib/python/django/db/transaction.pyRÆs     cCsG|dkrt}nt|ƒr7t||tƒ|ƒSt|||ƒS(sø Takes 3 things, an entering function (what to do to start this block of transaction management), an exiting function (what to do to end it, on both success and failure, and using which can be: None, indiciating using is DEFAULT_DB_ALIAS, a callable, indicating that using is DEFAULT_DB_ALIAS and to return the function already wrapped. Returns either a Transaction objects, which is both a decorator and a context manager, or a wrapped function, if using is a callable. N(RRtcallableR(RRR ((s.../Django//lib/python/django/db/transaction.pyt_transaction_funcâs    cCs"d„}d„}t|||ƒS(só Decorator that activates commit on save. This is Django's default behavior; this decorator is useful if you globally activated transaction management in your settings file and want the default behavior in some view functions. cSs'tdtd|ƒttd|ƒdS(NR R (R tFalseR (R ((s.../Django//lib/python/django/db/transaction.pyRýscSstd|ƒdS(NR (R (R#R ((s.../Django//lib/python/django/db/transaction.pyRs(R,(R RR((s.../Django//lib/python/django/db/transaction.pyt autocommit÷s  cCs"d„}d„}t|||ƒS(s  This decorator activates commit on response. This way, if the view function runs successfully, a commit is made; if the viewfunc produces an exception, a rollback is made. This is one of the most common ways to do transaction control in Web apps. cSs!td|ƒttd|ƒdS(NR (R R tTrue(R ((s.../Django//lib/python/django/db/transaction.pyR s cSs„zo|dk r1td|ƒrntd|ƒqnn=td|ƒrnytd|ƒWqntd|ƒ‚qnXnWdtd|ƒXdS(NR (RRRRR (R#R ((s.../Django//lib/python/django/db/transaction.pyRs  (R,(R RR((s.../Django//lib/python/django/db/transaction.pytcommit_on_successs  cCs"d„}d„}t|||ƒS(sô Decorator that activates manual transaction control. It just disables automatic transaction control and doesn't do any commit/rollback of its own -- it's up to the user to call the commit and rollback functions themselves. cSs!td|ƒttd|ƒdS(NR (R R R/(R ((s.../Django//lib/python/django/db/transaction.pyR)s cSstd|ƒdS(NR (R (R#R ((s.../Django//lib/python/django/db/transaction.pyR-s(R,(R RR((s.../Django//lib/python/django/db/transaction.pytcommit_manually"s  N( Rt functoolsRt django.dbRRt ExceptionRRRR/R R RRRRRR RRRRRRRtobjectRR,R.R0R1(((s.../Django//lib/python/django/db/transaction.pyt s0