Perform rollback

@param   string  $rollbackPoint  Tagname of rollback point
@return  bool
558252
public function rollback($rollbackPoint)
	{
		$tagname = 'cmsrollbackpoint-'.$rollbackPoint;

		// Make sure the tag exists first
		if (substr($this->call('show', array($tagname)), 0, 5 == 'fatal'))
		{
			return false;
		}

		// Do a hard reset - this is destructive!
		$this->call('reset', array('--hard', $tagname));

		return true;
	}
58516
public function rollBack()
    {
        if ($this->transactionNestingLevel === 0) {
            throw ConnectionException::noActiveTransaction();
        }

        $connection = $this->getWrappedConnection();

        $logger = $this->_config->getSQLLogger();

        if ($this->transactionNestingLevel === 1) {
            if ($logger) {
                $logger->startQuery('"ROLLBACK"');
            }
            $this->transactionNestingLevel = 0;
            $connection->rollBack();
            $this->isRollbackOnly = false;
            if ($logger) {
                $logger->stopQuery();
            }

            if ($this->autoCommit === false) {
                $this->beginTransaction();
            }
        } elseif ($this->nestTransactionsWithSavepoints) {
            if ($logger) {
                $logger->startQuery('"ROLLBACK TO SAVEPOINT"');
            }
            $this->rollbackSavepoint($this->_getNestedTransactionSavePointName());
            --$this->transactionNestingLevel;
            if ($logger) {
                $logger->stopQuery();
            }
        } else {
            $this->isRollbackOnly = true;
            --$this->transactionNestingLevel;
        }
    }
717814
public function rollbackTransaction()
    {
        $this->connect();
        if (!$this->_connection->inTransaction()) {
            return false;
        }

        return $this->_connection->rollBack();
    }
1067809
public function rollBack()
    {
        try {
            $this->rows = $this->snapshot;

            $this->storeAllTables();

            $this->snapshot = [];
        } catch (\Exception $e) {
            throw new \RuntimeException('Rollback failed: ' . $e->getMessage(), 0, $e);
        }
    }
843035
public function rollBack($rollBackTo = false)
    {
        if ($rollBackTo === false) {
            return $this->wlink->rollBack();
        } else {
            return $this->wlink->exec("ROLLBACK TO {$rollBackTo}");
        }
    }
1111256
public function rollback($throw=true)
	{
		if (!$this->transactionOpen && $throw) $this->throwError("Transaction not open  to rollback()","");
		if (!$this->isOpen) { $this->throwError("It's not connected to the database",""); return false; }
		$this->transactionOpen = false;
		return @$this->conn1->rollback();
	}
1231912
public function rollback()
	{
		if( $this->openTransactions == 0 )
			return false;
		$query = "ROLLBACK";
		$this->Execute( $query );
		$this->openTransactions = 0;
		return true;
	}
85496
public function rollback()
    {
        $res = null;

        if (empty($this->pendingTransactionBegin[$this->transLevel])
            && isset($this->transLevelRolledBack[$this->transLevel])
            && $this->transLevelRolledBack[$this->transLevel] == false
        ) {
            $this->dbRollback();
        }

        if ($this->transLevel == 0) {
            throw $this->createException('Rollback without transaction');
        }

        $this->cleanAfterCommit();
        $this->transLevel--;

        return $this;
    }
622782
public function transactionCommit($toSavepoint = false)
	{
		if (!$toSavepoint || $this->transactionDepth <= 1)
		{
			$this->connect();

			if ($this->connection->commit())
			{
				$this->transactionDepth = 0;
			}

			return;
		}

		$this->transactionDepth--;
	}
129415
public static function rollback()
	{
		// first of all we have to filter only the already migrated versions
		$available = static::available();
		
		foreach( $available as $key => $migrations )
		{
			foreach( $migrations as $time => $migration )
			{
				if ( $time > static::$config->get( $key.'.revision', 0 ) )
				{
					unset( $available[$key][$time] );
				}
			}
		}
		
		$revisions = array();
		
		foreach( $available as $key => $value )
		{
			if ( empty( $value ) )
			{
				continue;
			}
			
			foreach( $value as $name => $path )
			{
				$revisions[$name.'::'.$key] = $path;
			}
		}
		
		// nothing to rollback?
		if ( empty( $revisions ) )
		{
			if ( \ClanCats::is_cli() )
			{
				\CCCli::warning( 'nothing to rollback to.' );
			}
			
			return false;
		}
		
		ksort( $revisions );
		
		end( $revisions ); 
		list( $time, $key ) = explode( '::', key( $revisions ) );
		
		$migration = new static( array_pop( $revisions ) );
		
		// rollback the migration
		$migration->down();
		
		// get the lastet migration from the group
		$others = \CCArr::get( $key, $available );
		
		ksort( $others );
		array_pop( $others );
		end( $others );
		
		// update the config
		static::$config->set( $key.'.revision', key( $others ) );
		static::$config->write();
		
		return true;
	}
1304136
final public function transRollback()
    {
        $this->logger->info('-- TRANSACTION ROLLBACK ');
        // reduce the transaction level
        if ($this->transactionLevel === 0) {
            trigger_error('Try to call rollback without a transaction', E_USER_NOTICE);
            return;
        }
        $this->transactionLevel = $this->transactionLevel - 1;
        // do rollback or savepoint
        if (0 === $this->transactionLevel) {
            $this->commandTransactionRollback();
        } else {
            $this->commandRollbackToSavepoint("LEVEL_{$this->transactionLevel}");
        }
    }
778801
function rollback()
    {
        if ( is_array( $this->TransactionStackTree ) )
        {
            // All transactions were rollbacked, reset the tree.
            $this->TransactionStackTree = array();
        }
        $ini = eZINI::instance();
        if ($ini->variable( "DatabaseSettings", "Transactions" ) == "enabled")
        {
            if ( $this->TransactionCounter <= 0 )
            {
                eZDebug::writeError( 'No transaction in progress, cannot rollback', __METHOD__ );
                return false;
            }
            // Reset the transaction counter
            $this->TransactionCounter = 0;
            if ( $this->isConnected() )
            {
                $oldRecordError = $this->RecordError;
                // Turn off error handling while we rollback
                $this->RecordError = false;
                $this->rollbackQuery();
                $this->RecordError = $oldRecordError;
            }
        }
        return true;
    }
47127
public function rollBack() {
		if ($this->_transactionDepth == 0) {
			throw new PDOException('Rollback error : There is no transaction started');
		}

		$this->_transactionDepth--;

		if ($this->_transactionDepth == 0) {
			parent::rollBack();
		} else {
			$this->exec("ROLLBACK TO SAVEPOINT LEVEL{$this->_transactionDepth}");
		}
	}
297129
function rollback() {
		$this->savepoint--;

		if ($this->savepoint == 0) {
			\mysqli_rollback($this->dbh);
		}
		else { // not finished with transaction
			\mysqli_query('ROLLBACK TO SAVEPOINT save'.$this->savepoint);
		}

		return $this;
	}
503470
protected function rollbackTransaction($name = null)
    {
        $sql = "rollback transaction";
        if ($name !== null) {
            $sql = sprintf("rollback to savepoint %s", $this->escapeIdentifier($name));
        }

        $this->executeAnonymousQuery($sql);

        return $this;
    }
950804
public function rollback()
    {
        if (!$this->started) {
            throw new \RuntimeException('Cannot rollback transaction before start');
        }
        if (!$this->pdo->rollBack()) {
            throw new \RuntimeException('Failed to rollback transaction');
        }

        $this->started = false;
    }
1344948
public function rollback() {
		// Check permission
		if(!$this->canTriggerRollback()) {
			return Security::permissionFailure(
				null,
				_t("EmergencyRollbackStep.DENYROLLBACKED",
				"You do not have permission to rollback this pipeline")
			);
		}

		if ($this->Status == 'Queued') {
			$this->start();
		}

		// Write down some metadata.
		$this->RolledBack = SS_Datetime::now()->Rfc2822();
		$this->log(_t('EmergencyRollbackStep.BEINGROLLEDBACK', "{$this->Title} is being rolled back"));
		$this->ResponderID = Member::currentUserID();
		$this->write();

		// Rollback itself is handled by the Pipeline object. This step will be marked as failed.
		if ($this->Pipeline()->isRunning()) {
			$this->Pipeline()->markFailed();
			return true;
		} else {
			return false;
		}
	}