/*
(non-Javadoc)

@see javax.transaction.UserTransaction#rollback()
438983
@Override
    public void rollback() throws IllegalStateException, SecurityException, SystemException
    {

        try
        {
            Transaction tx = threadLocal.get();
            if (tx == null)
            {
                throw new IllegalStateException("Cannot locate a Transaction for rollback.");
            }

            if (log.isDebugEnabled())
                log.info("Rollback transaction:" + tx);

            tx.rollback();

        }
        finally
        {
            if (log.isDebugEnabled())
                log.info("Resetting after rollback.");
            threadLocal.set(null);
            timerThead.set(null);
        }
    }
502514
protected function rollback()
    {
        $transaction = array_pop($this->_transaction);
        if ($transaction && $transaction instanceof Transaction) {
            $transaction->rollBack();
        }
    }
847108
public void doRollback(DefaultTransactionStatus status) throws TransactionException {
		CompensatingTransactionObject txObject = (CompensatingTransactionObject) status.getTransaction();
		txObject.getHolder().getTransactionOperationManager().rollback();
	}
431941
protected function rollback_transaction() {
        $this->query_start('--oracle_rollback', NULL, SQL_QUERY_AUX);
        $result = oci_rollback($this->oci);
        $this->commit_status = OCI_COMMIT_ON_SUCCESS;
        $this->query_end($result);
    }
50915
public function rollBack()
    {
        if ($this->transactionLevel === 0) {
            throw ConnectionException::noActiveTransaction();
        }

        if ($this->transactionLevel === 1) {
            $queryDebugger = $this->createQueryDebugger('ROLLBACK TRANSACTION');
            $this->getDriverConnection()->rollBack();
            $this->debugQuery($queryDebugger);
        } else {
            $this->exec($this->getPlatform()->getRollbackSavepointSQLQuery($this->generateSavepointName()));
        }

        $this->transactionLevel--;
    }
649471
public function rollBack()
    {
        if (!$this->getIsActive()) {
            // do nothing if transaction is not active: this could be the transaction is committed
            // but the event handler to "commitTransaction" throw an exception
            return;
        }

        $this->_level--;
        if ($this->_level === 0) {
            Log::debug('Roll back transaction' . __METHOD__);
            $this->db->pdo->rollBack();
            $this->db->trigger(Connection::EVENT_ROLLBACK_TRANSACTION);
            return;
        }

        $schema = $this->db->getSchema();
        if ($schema->supportsSavepoint()) {
            Log::debug('Roll back to savepoint ' . $this->_level . __METHOD__);
            $schema->rollBackSavepoint('LEVEL' . $this->_level);
        } else {
            Log::info('Transaction not rolled back: nested transaction not supported' . __METHOD__);
            // throw an exception to fail the outer transaction
            throw new Exception('Roll back failed: nested transaction not supported.');
        }
    }
1205399
protected function _rollBack()
    {
        $this->_connect();
        $this->_connection->rollback();
        $this->_connection->autocommit(true);
    }
491456
@POST
    @Path("fcr:rollback")
    public Response rollback(@PathParam("path") final String externalPath) {

        LOGGER.info("Rollback transaction '{}'", externalPath);
        return finalizeTransaction(externalPath, getUserPrincipal(), false);
    }
724544
@Override
    public void rollback() throws DataCorruptedException, IOException, IllegalStateException{
        try {
            tranManager.rollback(t1);
        } catch (Exception e) {
            throw new DataCorruptedException("Error trying to rollback a Transaction.", e);
        }
    }
368473
void rollback(long fromTransactionId) {
        long traceId = LoggerHelpers.traceEnterWithContext(log, this.traceObjectId, "rollback", fromTransactionId);
        List<Long> rolledBack = new ArrayList<>();
        while (!this.transactions.isEmpty() && this.transactions.peekLast().getTransactionId() >= fromTransactionId) {
            ContainerMetadataUpdateTransaction txn = this.transactions.removeLast();
            txn.seal();
            rolledBack.add(txn.getTransactionId());
        }

        // At this point, the transaction list is either empty or its last one is sealed; any further changes would
        // require creating a new transaction.
        LoggerHelpers.traceLeave(log, this.traceObjectId, "rollback", traceId, rolledBack);
    }
1330974
@Override
    public void rollback() throws BackendException {
        Throwable excep = null;
        for (IndexTransaction itx : indexTx.values()) {
            try {
                itx.rollback();
            } catch (Throwable e) {
                excep = e;
            }
        }
        storeTx.rollback();
        if (excep!=null) { //throw any encountered index transaction rollback exceptions
            if (excep instanceof BackendException) throw (BackendException)excep;
            else throw new PermanentBackendException("Unexpected exception",excep);
        }
    }
1270704
public void rollback()
        throws DBException, RemoteException
    {
        BaseTransport transport = this.createProxyTransport(ROLLBACK);
        Object strReturn = transport.sendMessageAndGetReply();
        Object objReturn = transport.convertReturnObject(strReturn);
        this.checkDBException(objReturn);
    }
146010
@Override
    public void rollback(String globalId) throws HeuristicHazardException, HeuristicCommitException, HeuristicMixedException, SystemException {

        final TransactionWrapper t = TransactionWrapper.getTransactionWrapper(globalId);

        if (t != null) {
            t.rollback();
        } else {
            if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                Tr.debug(tc, "No matching TransactionWrapper: " + globalId);
            throw new SystemException();
        }
    }
1297887
public void rollback()
    {
        try
        {
            Iterator iter = mvOrderOfIds.iterator();
            while(iter.hasNext())
            {
                ObjectEnvelope mod = (ObjectEnvelope) mhtObjectEnvelopes.get(iter.next());
                if(log.isDebugEnabled())
                    log.debug("rollback: " + mod);
                // if the Object has been modified by transaction, mark object as dirty
                if(mod.hasChanged(transaction.getBroker()))
                {
                    mod.setModificationState(mod.getModificationState().markDirty());
                }
                mod.getModificationState().rollback(mod);
            }
        }
        finally
        {
            needsCommit = false;
        }
        afterWriteCleanup();
    }
299719
def rollback(self):
        
        if hasattr(self.local, 'tx') and self.local.tx:
            tx = self.local.tx.pop()
            tx.rollback()
            self._flush_tables()
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");
    }
1147606
public function rollBack() {
		if ($this->transactionManager === null) {
			$this->performRollBack();
			return;
		}
		
		if ($this->transactionManager->hasOpenTransaction()) {
			$this->transactionManager->getRootTransaction()->rollBack();
		}
	}