Rollbacks the transaction and rethrows the Throwable.
186949
public void doCatch(Throwable t) throws Throwable {
        if (conn != null) {
            try {
                conn.rollback();
            } catch (SQLException e) {
                // Ignore to not hide orignal exception
            }
        }
        throw t;
    }
1341377
@Override
	public void rollback() {
		Optional<LocalTransactionContext> txContext = currentTxContext();
		if (txContext.isPresent()) {
			txContext.get().rollback();
		} else {
			this.unmanagedTransaction.ifPresent(LocalTransactionContext::rollback);
		}
	}
221125
private function rollback()
    {
        // We only need to rollback if we are in a transaction. Otherwise the resulting
        // error would hide the real problem why rollback was called. We might not be
        // in a transaction when not using the transactional locking behavior or when
        // two callbacks (e.g. destroy and write) are invoked that both fail.
        if ($this->inTransaction) {
            if ('sqlite' === $this->driver) {
                $this->pdo->exec('ROLLBACK');
            } else {
                $this->pdo->rollBack();
            }
            $this->inTransaction = false;
        }
    }
877960
def rollback(self):
        """"""
        if self.session is not None:
            logger.info("rolling back transaction in %s" % self)
            self.session.close()
            self.session = None
            self.lock_update.release()
        else:
            logger.warning("rollback called but there's no open session in %s" % self)
1149052
def rollback(self):
		
		try:
			if self.connection is not None:
				self.connection.rollback()
				self._updateCheckTime()
				self.release()
		except Exception, e:
			pass
651863
def rollback(self):
        """"""
        self._state_machine.transition_to_rollback()
        for action in reversed(self._executed_actions):
            try:
                self.execute_with_retries(action, lambda a: a.rollback())
            except:  # pylint: disable=bare-except
                pass  # on exception, carry on with rollback of other steps
        self._state_machine.transition_to_rollback_complete()
229517
public function rollBack()
	{
		if ( $this->transactions == 1 )
		{
			$this->getPdo()->rollBack();
		}
		elseif ( $this->transactions > 1 && $this->queryGrammar->supportsSavepoints() )
		{
			$this->getPdo()->exec( $this->queryGrammar->compileSavepointRollBack( 'trans' . $this->transactions ) );
		}

		$this->transactions = max( 0, $this->transactions - 1 );

		$this->fireConnectionEvent( 'rollingBack' );
	}
640155
def _reset(self, force=False):
        
        if not self._closed and (force or self._transaction):
            try:
                self.rollback()
            except Exception:
                pass
735750
static void rollback(Connection connection) {
        if (connection != null)
            try {
                connection.rollback();
                log.debug("rolled back");
            } catch (SQLException e) {
                throw new SQLRuntimeException(e);
            }
    }
938903
public function rollback()
    {
        if (!$this->recv) {
            $this->receive();
            App::error('You forget to getResult() before rollback !');
        }
        $this->connection->query('rollback;');
    }
771121
def rollback(self):
        
        try:
            if self._autocommit:
                return

            if not self._conn or not self._conn.is_connected():
                return

            if not self._conn.tds72_transaction:
                return

            self._main_cursor._rollback(cont=True,
                                        isolation_level=self._isolation_level)
        except socket.error as e:
            if e.errno in (errno.ENETRESET, errno.ECONNRESET, errno.EPIPE):
                return
            self._conn.close()
            raise
        except ClosedConnectionError:
            pass
906338
public void rollback_only()
    {
        if (tc.isEntryEnabled())
            Tr.entry(tc, "rollback_only");

        try
        {
            _transaction.setRollbackOnly();
            _transaction.subRollback();
        } catch (Throwable exc)
        {
            FFDCFilter.processException(exc, "com.ibm.tx.remote.TransactionWrapper.rollback_only", "813", this);
            if (tc.isEventEnabled())
                Tr.event(tc, "rollback_only caught exception setting coordinator rollback_only", exc);
        }

        if (tc.isEntryEnabled())
            Tr.exit(tc, "rollback_only");
    }
703719
protected function rollback_transaction() {
        $this->query_start('native sqlsrv_rollback', NULL, SQL_QUERY_AUX);
        $result = sqlsrv_rollback($this->sqlsrv);
        $this->query_end($result);
    }
768358
public void rollback() throws SIIncorrectCallException, SIResourceException
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "rollback");

        if (_state != TransactionState.STATE_ACTIVE)
        {
            SIIncorrectCallException sie = new SIIncorrectCallException(nls.getFormattedMessage("CANNOT_ROLLBACK_COMPLETE_SIMS1005", new Object[]{}, null));
            if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled()) SibTr.event(this, tc, "Cannot rollback Transaction. Transaction is complete or completing!", sie);
            if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "rollback");
            throw sie;
        }

        _state = TransactionState.STATE_ROLLINGBACK;

        try
        {
            // We are rolling back all changes so we don't need
            // to tell the persistence layer to do anything we
            // just need to get the in memory model to back out
            // its changes.
            if (_workList != null)
            {
                _workList.rollback(this);
            }

            _state = TransactionState.STATE_ROLLEDBACK;
        }
        catch (Throwable t)
        {
            com.ibm.ws.ffdc.FFDCFilter.processException(t, "com.ibm.ws.sib.msgstore.transactions.MSDelegatingLocalTransaction.rollback", "1:539:1.51.1.14", this);
            if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled()) SibTr.event(this, tc, "Exception caught during rollback phase of transaction!", t);
            throw new SIResourceException(nls.getFormattedMessage("COMPLETION_EXCEPTION_SIMS1002", new Object[] {t}, null), t);
        }
        finally
        {
            // We always ensure that all afterCompletion
            // callbacks are called even in the case of
            // rollback.

            // Defect 316887
            try
            {
                if (_workList != null)
                {
                    _workList.postComplete(this, false);
                }

                for (int i = 0; i < _callbacks.size(); i++)
                {
                    TransactionCallback callback = (TransactionCallback) _callbacks.get(i);
                    callback.afterCompletion(this, false);
                }
            }
            catch (Throwable t)
            {
                com.ibm.ws.ffdc.FFDCFilter.processException(t, "com.ibm.ws.sib.msgstore.transactions.MSDelegatingLocalTransaction.rollback", "1:565:1.51.1.14", this);
                if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled()) SibTr.event(this, tc, "Exception caught during post rollback phase of transaction!", t);
                // We aren't going to rethrow this exception as if
                // a previous exception has been thrown outside the
                // finally block it is likely to have more
                // information about the root problem.
            }

            if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "rollback");
        }
    }
886912
def reopen(self):
        
        try:
            self._con.reopen()
        except Exception:
            if self._transcation:
                self._transaction = False
                try:
                    self._con.query('rollback')
                except Exception:
                    pass
        else:
            self._transaction = False
            self._closed = False
            self._setsession()
            self._usage = 0
1108284
public void rollback() throws DBCleanException
   {
      try
      {
         execute(rollbackingScripts);
      }
      catch (SQLException e)
      {
         throw new DBCleanException(JDBCUtils.getFullMessage(e), e);
      }
   }
133532
public function rollbackTransaction()
    {
        if (!self::$transaction) {
            throw new TransactionException("There is no Active Transaction");
        }

        self::$transaction = false;
        foreach (self::$connectionList as $dbDriver) {
            $dbDriver->rollbackTransaction();
        }
    }