WIP: Transaction

qiita_core/util.py

@@ -7,6 +7,7 @@
 # -----------------------------------------------------------------------------
 from smtplib import SMTP, SMTP_SSL, SMTPException
 from future import standard_library
+from functools import wraps
 
 from qiita_core.qiita_settings import qiita_config
 from qiita_db.sql_connection import SQLConnectionHandler
@@ -83,3 +84,13 @@ def tearDown(self):
 
         return DecoratedClass
     return class_modifier
+
+
+def execute_as_transaction(func):
+    """Decorator to make a method execute inside a transaction"""
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        from qiita_db.sql_connection import TRN
+        with TRN:
+            return func(*args, **kwargs)
+    return wrapper

qiita_db/base.py

@@ -26,9 +26,10 @@
 # -----------------------------------------------------------------------------
 
 from __future__ import division
+
 from qiita_core.exceptions import IncompetentQiitaDeveloperError
 from qiita_core.qiita_settings import qiita_config
-from .sql_connection import SQLConnectionHandler
+from .sql_connection import TRN
 from .exceptions import (QiitaDBNotImplementedError, QiitaDBUnknownIDError,
                          QiitaDBError)
 
@@ -131,11 +132,12 @@ def _check_id(self, id_):
         the other classes. However, still defining here as there is only one
         subclass that doesn't follow this convention and it can override this.
         """
-        conn_handler = SQLConnectionHandler()
-
-        return conn_handler.execute_fetchone(
-            "SELECT EXISTS(SELECT * FROM qiita.{0} WHERE "
-            "{0}_id=%s)".format(self._table), (id_, ))[0]
+        with TRN:
+            sql = """SELECT EXISTS(
+                        SELECT * FROM qiita.{0}
+                        WHERE {0}_id=%s)""".format(self._table)
+            TRN.add(sql, [id_])
+            return TRN.execute_fetchlast()
 
     def _check_portal(self, id_):
         """Checks that object is accessible in current portal
@@ -149,15 +151,15 @@ def _check_portal(self, id_):
             # assume not portal limited object
             return True
 
-        conn_handler = SQLConnectionHandler()
-
-        return conn_handler.execute_fetchone(
-            """SELECT EXISTS(
-                SELECT * from qiita.{0}
-                JOIN qiita.portal_type using (portal_type_id)
-                WHERE {1}_id = %s  AND portal = %s)""".format(
-                self._portal_table, self._table),
-            [id_, qiita_config.portal])[0]
+        with TRN:
+            sql = """SELECT EXISTS(
+                        SELECT *
+                        FROM qiita.{0}
+                            JOIN qiita.portal_type USING (portal_type_id)
+                        WHERE {1}_id = %s AND portal = %s
+                    )""".format(self._portal_table, self._table)
+            TRN.add(sql, [id_, qiita_config.portal])
+            return TRN.execute_fetchlast()
 
     def __init__(self, id_):
         r"""Initializes the object
@@ -171,14 +173,15 @@ def __init__(self, id_):
         QiitaDBUnknownIDError
             If `id_` does not correspond to any object
         """
-        self._check_subclass()
-        if not self._check_id(id_):
-            raise QiitaDBUnknownIDError(id_, self._table)
+        with TRN:
+            self._check_subclass()
+            if not self._check_id(id_):
+                raise QiitaDBUnknownIDError(id_, self._table)
 
-        if not self._check_portal(id_):
-            raise QiitaDBError("%s with id %d inaccessible in current portal: "
-                               "%s" % (self.__class__.__name__, id_,
-                                       qiita_config.portal))
+            if not self._check_portal(id_):
+                raise QiitaDBError(
+                    "%s with id %d inaccessible in current portal: %s"
+                    % (self.__class__.__name__, id_, qiita_config.portal))
 
         self._id = id_
 
@@ -216,18 +219,16 @@ class QiitaStatusObject(QiitaObject):
     @property
     def status(self):
         r"""String with the current status of the analysis"""
-        # Check that self._table is actually defined
-        self._check_subclass()
-
         # Get the DB status of the object
-        conn_handler = SQLConnectionHandler()
-        return conn_handler.execute_fetchone(
-            "SELECT status FROM qiita.{0}_status WHERE {0}_status_id = "
-            "(SELECT {0}_status_id FROM qiita.{0} WHERE "
-            "{0}_id = %s)".format(self._table),
-            (self._id, ))[0]
-
-    def _status_setter_checks(self, conn_handler):
+        with TRN:
+            sql = """SELECT status FROM qiita.{0}_status
+                     WHERE {0}_status_id = (
+                        SELECT {0}_status_id FROM qiita.{0}
+                        WHERE {0}_id = %s)""".format(self._table)
+            TRN.add(sql, [self._id])
+            return TRN.execute_fetchlast()
+
+    def _status_setter_checks(self):
         r"""Perform any extra checks that needed to be done before setting the
         object status on the database. Should be overwritten by the subclasses
         """
@@ -242,18 +243,18 @@ def status(self, status):
         status: str
             The new object status
         """
-        # Check that self._table is actually defined
-        self._check_subclass()
-
-        # Perform any extra checks needed before we update the status in the DB
-        conn_handler = SQLConnectionHandler()
-        self._status_setter_checks(conn_handler)
-
-        # Update the status of the object
-        conn_handler.execute(
-            "UPDATE qiita.{0} SET {0}_status_id = "
-            "(SELECT {0}_status_id FROM qiita.{0}_status WHERE status = %s) "
-            "WHERE {0}_id = %s".format(self._table), (status, self._id))
+        with TRN:
+            # Perform any extra checks needed before
+            # we update the status in the DB
+            self._status_setter_checks()
+
+            # Update the status of the object
+            sql = """UPDATE qiita.{0} SET {0}_status_id = (
+                        SELECT {0}_status_id FROM qiita.{0}_status
+                        WHERE status = %s)
+                     WHERE {0}_id = %s""".format(self._table)
+            TRN.add(sql, [status, self._id])
+            TRN.execute()
 
     def check_status(self, status, exclude=False):
         r"""Checks status of object.
@@ -285,21 +286,20 @@ def check_status(self, status, exclude=False):
         Table setup:
         foo: foo_status_id  ----> foo_status: foo_status_id, status
         """
-        # Check that self._table is actually defined
-        self._check_subclass()
-
-        # Get all available statuses
-        conn_handler = SQLConnectionHandler()
-
-        statuses = [x[0] for x in conn_handler.execute_fetchall(
-            "SELECT DISTINCT status FROM qiita.{0}_status".format(self._table),
-            (self._id, ))]
-
-        # Check that all the provided statuses are valid statuses
-        if set(status).difference(statuses):
-            raise ValueError("%s are not valid status values"
-                             % set(status).difference(statuses))
-
-        # Get the DB status of the object
-        dbstatus = self.status
-        return dbstatus not in status if exclude else dbstatus in status
+        with TRN:
+            # Get all available statuses
+            sql = "SELECT DISTINCT status FROM qiita.{0}_status".format(
+                self._table)
+            TRN.add(sql)
+            # We need to access to the results of the last SQL query,
+            # hence indexing using -1
+            avail_status = [x[0] for x in TRN.execute_fetchindex()]
+
+            # Check that all the provided status are valid status
+            if set(status).difference(avail_status):
+                raise ValueError("%s are not valid status values"
+                                 % set(status).difference(avail_status))
+
+            # Get the DB status of the object
+            dbstatus = self.status
+            return dbstatus not in status if exclude else dbstatus in status