simplify

Author: timgraham

django_mongodb_backend/base.py

@@ -152,18 +152,11 @@ def _isnull_operator(a, b):
     def __init__(self, settings_dict, alias=DEFAULT_DB_ALIAS):
         super().__init__(settings_dict, alias=alias)
         self.session = None
-
-        # Transaction related attributes.
-        # Tracks if the connection is in a transaction managed by 'atomic'.
+        # Tracks if the connection is in a transaction managed by
+        # django_mongodb_backend.transaction.atomic.
         self.in_atomic_block_mongo = False
         # Current number of nested 'atomic' calls.
         self.nested_atomics = 0
-        # Stack of active 'atomic' blocks.
-        self.atomic_blocks_mongo = []
-        # Tracks if the transaction should be rolled back to the next
-        # available savepoint because of an exception in an inner block.
-        self.needs_rollback_mongo = False
-        self.rollback_exc_mongo = None
 
     def get_collection(self, name, **kwargs):
         collection = Collection(self.database, name, **kwargs)
@@ -254,13 +247,6 @@ def close_pool(self):
     def cursor(self):
         return Cursor()
 
-    def validate_no_broken_transaction(self):
-        if self.needs_rollback_mongo:
-            raise TransactionManagementError(
-                "An error occurred in the current transaction. You can't "
-                "execute queries until the end of the 'atomic' block."
-            ) from self.rollback_exc
-
     def validate_no_atomic_block(self):
         """Raise an error if an atomic block is active."""
         if self.in_atomic_block_mongo:

django_mongodb_backend/compiler.py

@@ -678,7 +678,6 @@ def execute_sql(self, returning_fields=None):
     @wrap_database_errors
     def insert(self, docs, returning_fields=None):
         """Store a list of documents using field columns as element names."""
-        self.connection.validate_no_broken_transaction()
         inserted_ids = self.collection.insert_many(
             docs, session=self.connection.session
         ).inserted_ids
@@ -762,7 +761,6 @@ def execute_sql(self, result_type):
 
     @wrap_database_errors
     def update(self, criteria, pipeline):
-        self.connection.validate_no_broken_transaction()
         return self.collection.update_many(
             criteria, pipeline, session=self.connection.session
         ).matched_count

django_mongodb_backend/query.py

@@ -61,7 +61,6 @@ def __repr__(self):
     @wrap_database_errors
     def delete(self):
         """Execute a delete query."""
-        self.compiler.connection.validate_no_broken_transaction()
         if self.compiler.subqueries:
             raise NotSupportedError("Cannot use QuerySet.delete() when a subquery is required.")
         return self.compiler.collection.delete_many(
@@ -74,7 +73,6 @@ def get_cursor(self):
         Return a pymongo CommandCursor that can be iterated on to give the
         results of the query.
         """
-        self.compiler.connection.validate_no_broken_transaction()
         return self.compiler.collection.aggregate(
             self.get_pipeline(), session=self.compiler.connection.session
         )

django_mongodb_backend/transaction.py

@@ -1,6 +1,6 @@
 from contextlib import ContextDecorator
 
-from django.db import DEFAULT_DB_ALIAS, DatabaseError, Error
+from django.db import DEFAULT_DB_ALIAS, DatabaseError
 from django.db.transaction import get_connection
 
 
@@ -30,82 +30,61 @@ class Atomic(ContextDecorator):
     `with oa:` multiple times.
 
     Since database connections are thread-local, this is thread-safe.
+
+    Simplified from django.db.transaction.
     """
 
     def __init__(self, using):
         self.using = using
 
     def __enter__(self):
         connection = get_connection(self.using)
-        if not connection.in_atomic_block_mongo:
-            # Reset state when entering an outermost atomic block.
-            connection.needs_rollback_mongo = False
-
         if connection.in_atomic_block_mongo:
-            # We're already in a transaction. Increment the number of nested atomics.
+            # If we're already in an atomic(), track the number of nested calls.
             connection.nested_atomics += 1
         else:
+            # Start a transaction for the outermost atomic().
             connection._start_transaction()
             connection.in_atomic_block_mongo = True
 
-        if connection.in_atomic_block_mongo:
-            connection.atomic_blocks_mongo.append(self)
-
     def __exit__(self, exc_type, exc_value, traceback):
         connection = get_connection(self.using)
-
-        if connection.in_atomic_block_mongo:
-            connection.atomic_blocks_mongo.pop()
-
         if connection.nested_atomics:
             connection.nested_atomics -= 1
         else:
-            # Prematurely unset this flag to allow using commit or rollback.
             connection.in_atomic_block_mongo = False
         try:
-            if exc_type is None and not connection.needs_rollback_mongo:
+            if exc_type is None:
+                # atomic() exited without an error.
                 if connection.in_atomic_block_mongo:
-                    # Release savepoint if there is one
+                    # Do nothing for an inner atomic().
                     pass
                 else:
-                    # Commit transaction
+                    # Commit transaction.
                     try:
                         connection.commit_mongo()
                     except DatabaseError:
-                        try:
-                            connection.rollback_mongo()
-                        except Error:
-                            # An error during rollback means that something
-                            # went wrong with the connection. Drop it.
-                            connection.close()
-                        raise
+                        connection.rollback_mongo()
             else:
-                # This flag will be set to True again if there isn't a savepoint
-                # allowing to perform the rollback at this level.
-                connection.needs_rollback_mongo = False
+                # atomic() exited with an error.
                 if connection.in_atomic_block_mongo:
-                    # Mark for rollback
-                    connection.needs_rollback_mongo = True
+                    # Do nothing for an inner atomic().
+                    pass
                 else:
-                    # Roll back transaction
-                    try:
-                        connection.rollback_mongo()
-                    except Error:
-                        # An error during rollback means that something
-                        # went wrong with the connection. Drop it.
-                        connection.close()
+                    # Rollback transaction.
+                    connection.rollback_mongo()
         finally:
-            # Outermost block exit
             if (
                 not connection.in_atomic_block_mongo
                 and connection.run_commit_hooks_on_set_autocommit_on
             ):
+                # Run on_commit() callbacks after outermost atomic()
                 connection.run_and_clear_commit_hooks()
 
 
 def atomic(using=None):
-    # Bare decorator: @atomic -- although the first argument is called
-    # `using`, it's actually the function being decorated.
+    # Bare decorator: @atomic -- although the first argument is called `using`, it's
+    # actually the function being decorated.
     if callable(using):
         return Atomic(DEFAULT_DB_ALIAS)(using)
     # Decorator: @atomic(...) or context manager: with atomic(...): ...

docs/source/topics/transactions.rst

@@ -68,10 +68,7 @@ Controlling transactions
         This is mostly a concern for :exc:`~django.db.DatabaseError` and its subclasses
         such as :exc:`~django.db.IntegrityError`. After such an error, the transaction
         is broken and Django will perform a rollback at the end of the ``atomic``
-        block. If you attempt to run database queries before the rollback happens,
-        Django will raise a :class:`~django.db.transaction.TransactionManagementError`.
-        You may also encounter this behavior when an ORM-related signal handler raises
-        an exception.
+        block.
 
     .. admonition:: You may need to manually revert app state when rolling back a transaction.
 

tests/transactions_/tests.py

@@ -119,8 +119,7 @@ class Callable:
             def __call__(self):
                 pass
 
-        # Must not raise an exception
-        transaction.atomic(Callable())
+        transaction.atomic(Callable())  # Must not raise an exception
 
 
 @skipIfDBFeature("_supports_transactions")