Get the latest rollback point

@return  string|bool
191356
public function getRollbackPoint()
	{
		$tagList = $this->call('tag');
		$tags    = explode("\n", $tagList);
		$rbp     = 0;

		if (count($tags) > 0)
		{
			foreach ($tags as $tag)
			{
				if (strstr($tag, 'cmsrollbackpoint-') !== false)
				{
					$tmp_tag = substr($tag, 17);
					if ($tmp_tag > $rbp)
					{
						$rbp = $tmp_tag;
					}
				}
			}

			if ($rbp === 0)
			{
				return false;
			}

			return $rbp;
		}
		else
		{
			return false;
		}
	}
825971
public function rollback()
    {
        switch ($this->mode) {

            case "mysql":
                $result = $this->server->rollback();
                break;

            case "postgres":
            case "redshift":
                $result = $this->query("ROLLBACK");
                break;

            case "odbc":
                $result = odbc_rollback($this->server);
                break;

            default:
                throw new \Exception("rollback() not supported in this mode (" . $this->mode . ")");
        }

        if (!$result) {
            $this->error();
        }

        return true;
    }
576143
public function rollback()
    {
        $this->initConnect(true);

        if (1 == $this->transTimes) {
            $this->linkID->rollBack();
        } elseif ($this->transTimes > 1 && $this->supportSavepoint()) {
            $this->linkID->exec(
                $this->parseSavepointRollBack('trans' . $this->transTimes)
            );
        }

        $this->transTimes = max(0, $this->transTimes - 1);
    }
1064155
public function rollback()
    {
        $this->attributes->rollback();
        $this->hasOneEmbeds->rollback();
        $this->hasManyEmbeds->rollback();
        $this->doDirtyCheck();
        return $this;
    }
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;
	}
1200785
public function get_transaction_start_backtrace() {
        if (!$this->transactions) {
            return null;
        }
        $lowesttransaction = end($this->transactions);
        return $lowesttransaction->get_backtrace();
    }
1032644
public function rollback() {
		if (!$this->inTransaction()) {
			throw new Exception('There is no active transaction');
		}

		$res = @oci_rollback($this->_dbh);
		$this->checkError($res);

		$this->_inTransaction = false;
		$this->_commitMode = null;

		return $res;
	}
213609
protected function GetReturnToLastStepURL()
    {
        $sLink = false;
        $oBackItem = $this->GetPreviousStep();
        if (!is_null($oBackItem)) {
            $sLink = $oBackItem->GetStepURL();
        }

        return $sLink;
    }
652194
public function rollbackTransaction()
    {
        $this->db_connect('w', true);

        // check connection before proceeding
        if (!$this->is_connected()) {
            return $this->last_result = false;
        }

        $this->debug('ROLLBACK TRANSACTION');

        if (@oci_rollback($this->dbh)) {
            $this->in_transaction = false;
        }
        else {
            $this->handle_error('ROLLBACK');
        }

        return $this->last_result = $this->dbh->rollBack();
    }
244246
public function rollback() {
        if ($files = $this->getAllFiles()) {
            foreach ($files as $file) {
                if ($file instanceof File) {
                    $file->delete();
                }
            }
        }

        $this->_file = null;
        $this->_files = array();

        return $this;
    }
625654
public function rollbackTransaction() {
		$request = new CPS_RollbackTransactionRequest();
		$this->_lastResponse = $this->_connection->sendRequest($request);
		return true;
	}
1166453
public function rollBack() : bool
    {
        return $this->isConnected() && $this->getConnection()->inTransaction() && $this->getConnection()->rollBack();
    }
73706
public function rollBack() {
        $arg = mysql_query('ROLLBACK', $this->driver);
        $result = empty($arg);
        mysql_query('END', $this->driver);
        return $result;
    }
109399
public function getCurrentRelease()
    {
        $current = Arr::get($this->getValidReleases(), 0);
        $current = $this->sanitizeRelease($current);

        return $this->nextRelease ?: $current;
    }
306482
public function getLastRow()
    {
        $rows = $this->data['rows'];
        if (empty($rows)) {
            return false;
        }

        $row = array_slice($rows, count($rows) - 1);

        return current($row);
    }
1196000
public function rollbackTransaction() {
        $this->_fireEvent('phpsweetpdo.rollback_transaction.started', array ());
        $result = $this->_pdoObject->rollBack();
        $this->_fireEvent('phpsweetpdo.rollback_transaction.finished', array ('result' => &$result));

        return $result;
    }
1189362
public function rollbackTransaction()
    {
        try {
            $this->_pdo->rollBack();
            $this->_lastCheckTime = time();
        } catch (\PDOException $e) {
            $this->_error($e->getMessage(), FQDBException::PDO_CODE, $e);
        }
    }