fix #2868

qiita_db/analysis.py

@@ -355,11 +355,9 @@ def description(self, description):
         QiitaDBStatusError
             Analysis is public
         """
-        with qdb.sql_connection.TRN:
-            sql = """UPDATE qiita.{0} SET description = %s
-                     WHERE analysis_id = %s""".format(self._table)
-            qdb.sql_connection.TRN.add(sql, [description, self._id])
-            qdb.sql_connection.TRN.execute()
+        sql = """UPDATE qiita.{0} SET description = %s
+                 WHERE analysis_id = %s""".format(self._table)
+        qdb.sql_connection.perform_as_transaction(sql, [description, self._id])
 
     @property
     def samples(self):
@@ -513,11 +511,9 @@ def pmid(self, pmid):
         -----
         An analysis should only ever have one PMID attached to it.
         """
-        with qdb.sql_connection.TRN:
-            sql = """UPDATE qiita.{0} SET pmid = %s
-                     WHERE analysis_id = %s""".format(self._table)
-            qdb.sql_connection.TRN.add(sql, [pmid, self._id])
-            qdb.sql_connection.TRN.execute()
+        sql = """UPDATE qiita.{0} SET pmid = %s
+                 WHERE analysis_id = %s""".format(self._table)
+        qdb.sql_connection.perform_as_transaction(sql, [pmid, self._id])
 
     @property
     def can_be_publicized(self):
@@ -618,13 +614,11 @@ def set_error(self, error_msg):
         error_msg : str
             The error message
         """
-        with qdb.sql_connection.TRN:
-            le = qdb.logger.LogEntry.create('Runtime', error_msg)
-            sql = """UPDATE qiita.analysis
-                     SET logging_id = %s
-                     WHERE analysis_id = %s"""
-            qdb.sql_connection.TRN.add(sql, [le.id, self.id])
-            qdb.sql_connection.TRN.execute()
+        le = qdb.logger.LogEntry.create('Runtime', error_msg)
+        sql = """UPDATE qiita.analysis
+                 SET logging_id = %s
+                 WHERE analysis_id = %s"""
+        qdb.sql_connection.perform_as_transaction(sql, [le.id, self.id])
 
     def has_access(self, user):
         """Returns whether the given user has access to the analysis
@@ -696,11 +690,9 @@ def share(self, user):
         if user.id == self.owner or user.id in self.shared_with:
             return
 
-        with qdb.sql_connection.TRN:
-            sql = """INSERT INTO qiita.analysis_users (analysis_id, email)
-                     VALUES (%s, %s)"""
-            qdb.sql_connection.TRN.add(sql, [self._id, user.id])
-            qdb.sql_connection.TRN.execute()
+        sql = """INSERT INTO qiita.analysis_users (analysis_id, email)
+                 VALUES (%s, %s)"""
+        qdb.sql_connection.perform_as_transaction(sql, [self._id, user.id])
 
     def unshare(self, user):
         """Unshare the analysis with another user
@@ -710,11 +702,9 @@ def unshare(self, user):
         user: User object
             The user to unshare the analysis with
         """
-        with qdb.sql_connection.TRN:
-            sql = """DELETE FROM qiita.analysis_users
-                     WHERE analysis_id = %s AND email = %s"""
-            qdb.sql_connection.TRN.add(sql, [self._id, user.id])
-            qdb.sql_connection.TRN.execute()
+        sql = """DELETE FROM qiita.analysis_users
+                 WHERE analysis_id = %s AND email = %s"""
+        qdb.sql_connection.perform_as_transaction(sql, [self._id, user.id])
 
     def _lock_samples(self):
         """Only dflt analyses can have samples added/removed

qiita_db/artifact.py

@@ -388,8 +388,7 @@ def _associate_with_analysis(instance, analysis_id):
                         (analysis_id, artifact_id)
                      VALUES (%s, %s)"""
             sql_args = [analysis_id, instance.id]
-            qdb.sql_connection.TRN.add(sql, sql_args)
-            qdb.sql_connection.TRN.execute()
+            qdb.sql_connection.perform_as_transaction(sql, sql_args)
 
         with qdb.sql_connection.TRN:
             if parents:
@@ -673,12 +672,10 @@ def name(self, value):
         ValueError
             If `value` contains more than 35 chars
         """
-        with qdb.sql_connection.TRN:
-            sql = """UPDATE qiita.artifact
-                     SET name = %s
-                     WHERE artifact_id = %s"""
-            qdb.sql_connection.TRN.add(sql, [value, self.id])
-            qdb.sql_connection.TRN.execute()
+        sql = """UPDATE qiita.artifact
+                 SET name = %s
+                 WHERE artifact_id = %s"""
+        qdb.sql_connection.perform_as_transaction(sql, [value, self.id])
 
     @property
     def timestamp(self):
@@ -751,8 +748,7 @@ def _set_visibility(self, value):
         sql = """UPDATE qiita.artifact
                  SET visibility_id = %s
                  WHERE artifact_id IN %s"""
-        qdb.sql_connection.TRN.add(sql, [vis_id, tuple(ids)])
-        qdb.sql_connection.TRN.execute()
+        qdb.sql_connection.perform_as_transaction(sql, [vis_id, tuple(ids)])
 
     @visibility.setter
     def visibility(self, value):
@@ -989,15 +985,13 @@ def is_submitted_to_vamps(self, value):
         QiitaDBOperationNotPermittedError
             If the artifact cannot be submitted to VAMPS
         """
-        with qdb.sql_connection.TRN:
-            if not self.can_be_submitted_to_vamps:
-                raise qdb.exceptions.QiitaDBOperationNotPermittedError(
-                    "Artifact %s cannot be submitted to VAMPS" % self.id)
-            sql = """UPDATE qiita.artifact
-                     SET submitted_to_vamps = %s
-                     WHERE artifact_id = %s"""
-            qdb.sql_connection.TRN.add(sql, [value, self.id])
-            qdb.sql_connection.TRN.execute()
+        if not self.can_be_submitted_to_vamps:
+            raise qdb.exceptions.QiitaDBOperationNotPermittedError(
+                "Artifact %s cannot be submitted to VAMPS" % self.id)
+        sql = """UPDATE qiita.artifact
+                 SET submitted_to_vamps = %s
+                 WHERE artifact_id = %s"""
+        qdb.sql_connection.perform_as_transaction(sql, [value, self.id])
 
     @property
     def filepaths(self):

qiita_db/download_link.py

@@ -72,10 +72,8 @@ def delete(cls, jti):
         jti : object
             The jwt token identifier
         """
-        with qdb.sql_connection.TRN:
-            sql = """DELETE FROM qiita.{0} WHERE jti=%s""".format(cls._table)
-            qdb.sql_connection.TRN.add(sql, [jti])
-            qdb.sql_connection.TRN.execute()
+        sql = """DELETE FROM qiita.{0} WHERE jti=%s""".format(cls._table)
+        qdb.sql_connection.perform_as_transaction(sql, [jti])
 
     @classmethod
     def exists(cls, jti):
@@ -98,10 +96,8 @@ def delete_expired(cls):
         r"""Deletes all expired download links"""
         now = datetime.now(timezone.utc)
 
-        with qdb.sql_connection.TRN:
-            sql = """DELETE FROM qiita.{0} WHERE exp<%s""".format(cls._table)
-            qdb.sql_connection.TRN.add(sql, [now])
-            qdb.sql_connection.TRN.execute()
+        sql = """DELETE FROM qiita.{0} WHERE exp<%s""".format(cls._table)
+        qdb.sql_connection.perform_as_transaction(sql, [now])
 
     @classmethod
     def get(cls, jti):

qiita_db/logger.py

@@ -181,12 +181,9 @@ def msg(self):
     def clear_info(self):
         """Resets the list of info dicts to be an empty list
         """
-        with qdb.sql_connection.TRN:
-            sql = """UPDATE qiita.{} SET information = %s
-                     WHERE logging_id = %s""".format(self._table)
-            qdb.sql_connection.TRN.add(sql, [dumps([]), self.id])
-
-            qdb.sql_connection.TRN.execute()
+        sql = """UPDATE qiita.{} SET information = %s
+                 WHERE logging_id = %s""".format(self._table)
+        qdb.sql_connection.perform_as_transaction(sql, [dumps([]), self.id])
 
     def add_info(self, info):
         """Adds new information to the info associated with this LogEntry
@@ -201,12 +198,10 @@ def add_info(self, info):
         - When `info` is added, keys can be of any type, but upon retrieval,
           they will be of type str
         """
-        with qdb.sql_connection.TRN:
-            current_info = self.info
-            current_info.append(info)
-            new_info = dumps(current_info)
+        current_info = self.info
+        current_info.append(info)
+        new_info = dumps(current_info)
 
-            sql = """UPDATE qiita.{} SET information = %s
-                     WHERE logging_id = %s""".format(self._table)
-            qdb.sql_connection.TRN.add(sql, [new_info, self.id])
-            qdb.sql_connection.TRN.execute()
+        sql = """UPDATE qiita.{} SET information = %s
+                 WHERE logging_id = %s""".format(self._table)
+        qdb.sql_connection.perform_as_transaction(sql, [new_info, self.id])

qiita_db/meta_util.py

@@ -335,11 +335,9 @@ def sizeof_fmt(value, position):
 
     # preparing vals to insert into DB
     vals = dumps(dict([x[:-1] for x in vals]))
-    with qdb.sql_connection.TRN:
-        sql = """INSERT INTO qiita.stats_daily (stats, stats_timestamp)
-                 VALUES (%s, NOW())"""
-        qdb.sql_connection.TRN.add(sql, [vals])
-        qdb.sql_connection.TRN.execute()
+    sql = """INSERT INTO qiita.stats_daily (stats, stats_timestamp)
+             VALUES (%s, NOW())"""
+    qdb.sql_connection.perform_as_transaction(sql, [vals])
 
     return missing_files
 

qiita_db/metadata_template/base_metadata_template.py

@@ -279,19 +279,18 @@ def setitem(self, column, value):
         QiitaDBColumnError
             If the column does not exist in the table
         """
-        with qdb.sql_connection.TRN:
-            # Check if the column exist in the table
-            if column not in self._get_categories():
-                raise qdb.exceptions.QiitaDBColumnError(
-                    "Column %s does not exist in %s" %
-                    (column, self._dynamic_table))
+        # Check if the column exist in the table
+        if column not in self._get_categories():
+            raise qdb.exceptions.QiitaDBColumnError(
+                "Column %s does not exist in %s" %
+                (column, self._dynamic_table))
 
-            sql = """UPDATE qiita.{0}
-                     SET sample_values = sample_values || %s
-                     WHERE sample_id = %s""".format(self._dynamic_table)
+        sql = """UPDATE qiita.{0}
+                 SET sample_values = sample_values || %s
+                 WHERE sample_id = %s""".format(self._dynamic_table)
 
-            qdb.sql_connection.TRN.add(sql, [dumps({column: value}), self.id])
-            qdb.sql_connection.TRN.execute()
+        qdb.sql_connection.perform_as_transaction(
+            sql, [dumps({column: value}), self.id])
 
     def __setitem__(self, column, value):
         r"""Sets the metadata value for the category `column`

qiita_db/metadata_template/prep_template.py

@@ -453,14 +453,13 @@ def investigation_type(self, investigation_type):
         QiitaDBColumnError
             If the investigation type is not a valid ENA ontology
         """
-        with qdb.sql_connection.TRN:
-            if investigation_type is not None:
-                self.validate_investigation_type(investigation_type)
+        if investigation_type is not None:
+            self.validate_investigation_type(investigation_type)
 
-            sql = """UPDATE qiita.prep_template SET investigation_type = %s
-                     WHERE {0} = %s""".format(self._id_column)
-            qdb.sql_connection.TRN.add(sql, [investigation_type, self.id])
-            qdb.sql_connection.TRN.execute()
+        sql = """UPDATE qiita.prep_template SET investigation_type = %s
+                 WHERE {0} = %s""".format(self._id_column)
+        qdb.sql_connection.perform_as_transaction(
+            sql, [investigation_type, self.id])
 
     @property
     def study_id(self):
@@ -494,11 +493,9 @@ def deprecated(self, deprecated):
         deprecated : bool
             If the prep info file is deprecated
         """
-        with qdb.sql_connection.TRN:
-            sql = """UPDATE qiita.prep_template SET deprecated = %s
-                     WHERE {0} = %s""".format(self._id_column)
-            qdb.sql_connection.TRN.add(sql, [deprecated, self.id])
-            qdb.sql_connection.TRN.execute()
+        sql = """UPDATE qiita.prep_template SET deprecated = %s
+                 WHERE {0} = %s""".format(self._id_column)
+        qdb.sql_connection.perform_as_transaction(sql, [deprecated, self.id])
 
     def generate_files(self, samples=None, columns=None):
         r"""Generates all the files that contain data from this template
@@ -761,12 +758,10 @@ def name(self):
     @name.setter
     def name(self, value):
         """Changes the name of the prep template"""
-        with qdb.sql_connection.TRN:
-            sql = """UPDATE qiita.prep_template
-                     SET name = %s
-                     WHERE prep_template_id = %s"""
-            qdb.sql_connection.TRN.add(sql, [value, self.id])
-            qdb.sql_connection.TRN.execute()
+        sql = """UPDATE qiita.prep_template
+                 SET name = %s
+                 WHERE prep_template_id = %s"""
+        qdb.sql_connection.perform_as_transaction(sql, [value, self.id])
 
     def to_dataframe(self, add_ebi_accessions=False):
         """Returns the metadata template as a dataframe

qiita_db/ontology.py

@@ -77,16 +77,14 @@ def add_user_defined_term(self, term):
         term : str
             New user defined term to add into a given ontology
         """
-        with qdb.sql_connection.TRN:
-            # we don't need to add an existing term
-            terms = self.user_defined_terms + self.terms
-
-            if term not in terms:
-                sql = """INSERT INTO qiita.term
-                            (ontology_id, term, user_defined)
-                         VALUES (%s, %s, true);"""
-                qdb.sql_connection.TRN.add(sql, [self.id, term])
-                qdb.sql_connection.TRN.execute()
+        # we don't need to add an existing term
+        terms = self.user_defined_terms + self.terms
+
+        if term not in terms:
+            sql = """INSERT INTO qiita.term
+                        (ontology_id, term, user_defined)
+                     VALUES (%s, %s, true);"""
+            qdb.sql_connection.perform_as_transaction(sql, [self.id, term])
 
     def term_type(self, term):
         """Get the type of a given ontology term

qiita_db/portal.py

@@ -72,38 +72,36 @@ def create(cls, portal, desc):
         QiitaDBDuplicateError
             Portal name already exists
         """
-        with qdb.sql_connection.TRN:
-            if cls.exists(portal):
-                raise qdb.exceptions.QiitaDBDuplicateError("Portal", portal)
-
-            # Add portal and default analyses for all users
-            sql = """DO $do$
-                DECLARE
-                    pid bigint;
-                    eml varchar;
-                    aid bigint;
-                BEGIN
-                    INSERT INTO qiita.portal_type (portal, portal_description)
-                    VALUES (%s, %s)
-                    RETURNING portal_type_id INTO pid;
-
-                    FOR eml IN
-                        SELECT email FROM qiita.qiita_user
-                    LOOP
-                        INSERT INTO qiita.analysis
-                            (email, name, description, dflt)
-                        VALUES (eml, eml || '-dflt', 'dflt', true)
-                        RETURNING analysis_id INTO aid;
-
-                        INSERT INTO qiita.analysis_portal
-                            (analysis_id, portal_type_id)
-                        VALUES (aid, pid);
-                    END LOOP;
-                END $do$;"""
-            qdb.sql_connection.TRN.add(sql, [portal, desc])
-            qdb.sql_connection.TRN.execute()
+        if cls.exists(portal):
+            raise qdb.exceptions.QiitaDBDuplicateError("Portal", portal)
+
+        # Add portal and default analyses for all users
+        sql = """DO $do$
+            DECLARE
+                pid bigint;
+                eml varchar;
+                aid bigint;
+            BEGIN
+                INSERT INTO qiita.portal_type (portal, portal_description)
+                VALUES (%s, %s)
+                RETURNING portal_type_id INTO pid;
+
+                FOR eml IN
+                    SELECT email FROM qiita.qiita_user
+                LOOP
+                    INSERT INTO qiita.analysis
+                        (email, name, description, dflt)
+                    VALUES (eml, eml || '-dflt', 'dflt', true)
+                    RETURNING analysis_id INTO aid;
+
+                    INSERT INTO qiita.analysis_portal
+                        (analysis_id, portal_type_id)
+                    VALUES (aid, pid);
+                END LOOP;
+            END $do$;"""
+        qdb.sql_connection.perform_as_transaction(sql, [portal, desc])
 
-            return cls(portal)
+        return cls(portal)
 
     @staticmethod
     def delete(portal):