def _handle_nested(self): """The NESTED propagation policy would commit all changes in the outer and inner transactions together when the outer policy commits. However, if an exception is thrown in the inner transaction all changes there would get thrown out but allow the outer transaction to optionally recover and continue. The NESTED policy is not supported. If you use this policy, your code will throw a BadRequestError exception. """ raise exceptions.BadRequestError( "Nested transactions are not supported.")
def _handle_mandatory(self): """Always propagate an existing transaction; throw an exception if there is no existing transaction. If a function that uses this policy throws an exception, it's probably not safe to catch the exception and commit the outer transaction; the function may have left the outer transaction in a bad state. """ if not in_transaction(): raise exceptions.BadRequestError( "Requires an existing transaction.")
def non_transactional_inner_wrapper(*args, **kwargs): from . import context ctx = context.get_context() if not ctx.in_transaction(): return wrapped(*args, **kwargs) if not allow_existing: raise exceptions.BadRequestError( "{} cannot be called within a transaction".format( wrapped.__name__)) new_ctx = ctx.new(transaction=None) with new_ctx.use(): return wrapped(*args, **kwargs)
def non_transactional_inner_wrapper(*args, **kwargs): # Avoid circular import in Python 2.7 from google.cloud.ndb import context as context_module context = context_module.get_context() if not context.in_transaction(): return wrapped(*args, **kwargs) if not allow_existing: raise exceptions.BadRequestError( "{} cannot be called within a transaction".format( wrapped.__name__)) new_context = context.new(transaction=None) with new_context.use(): return wrapped(*args, **kwargs)