PHP odbc_rollback函数代码示例

 /**
  * rollback the sql transaction
  *
  */
 protected function rollbackTransaction()
 {
     if (self::$transactionStarted[$this->datastore] == true) {
         if (!odbc_rollback($this->con)) {
             throw new Exception('unable to rollback transaction: ' . odbc_errormsg($this->con));
         }
         self::$transactionStarted[$this->datastore] = false;
     }
 }

 /**
  * SQL Transaction
  * @access: private
  */
 function _sql_transaction($status = 'begin')
 {
     switch ($status) {
         case 'begin':
             return @odbc_autocommit($this->db_connect_id, false);
             break;
         case 'commit':
             $result = @odbc_commit($this->db_connect_id);
             @odbc_autocommit($this->db_connect_id, true);
             return $result;
             break;
         case 'rollback':
             $result = @odbc_rollback($this->db_connect_id);
             @odbc_autocommit($this->db_connect_id, true);
             return $result;
             break;
     }
     return true;
 }

 /**
  * Rollback a transaction
  *
  * @param unknown_type $model
  * @return boolean True on success, false on fail
  * (i.e. if the database/model does not support transactions,
  * or a transaction has not started).
  */
 function rollback(&$model)
 {
     if (parent::rollback($model)) {
         $this->_transactionStarted = false;
         return odbc_rollback($this->connection);
     }
     return false;
 }

 /**
  * Executes given SQL statement.
  *
  * @param string $sql SQL statement
  * @return resource Result resource identifier
  * @access protected
  */
 function _execute($sql)
 {
     switch ($sql) {
         case 'BEGIN':
             return odbc_autocommit($this->connection, false);
         case 'COMMIT':
             return odbc_commit($this->connection);
         case 'ROLLBACK':
             return odbc_rollback($this->connection);
     }
     // TODO: should flags be set? possible requirement:  SQL_CURSOR_STATIC
     return odbc_exec($this->connection, $sql);
 }

 function rollback()
 {
     //5.3.0
     return odbc_rollback($this->_LINK);
 }

 /**
  * Rollback Transaction
  *
  * @return	bool
  */
 public function trans_rollback()
 {
     // When transactions are nested we only begin/commit/rollback the outermost ones
     if (!$this->trans_enabled or $this->_trans_depth > 0) {
         return TRUE;
     }
     $ret = odbc_rollback($this->conn_id);
     odbc_autocommit($this->conn_id, TRUE);
     return $ret;
 }

 function RollbackTrans()
 {
     if ($this->transOff) {
         return true;
     }
     if ($this->transCnt) {
         $this->transCnt -= 1;
     }
     $this->_autocommit = true;
     $ret = odbc_rollback($this->_connectionID);
     odbc_autocommit($this->_connectionID, true);
     return $ret;
 }

 /**
  * Rollback Transaction
  *
  * @return	bool
  */
 protected function _trans_rollback()
 {
     if (odbc_rollback($this->conn_id)) {
         odbc_autocommit($this->conn_id, TRUE);
         return TRUE;
     }
     return FALSE;
 }

 /**
  * Makes sure each database and extension handles BEGIN, COMMIT and ROLLBACK 
  * 
  * @param  string &$sql          The SQL to check for a transaction query
  * @param  string $result_class  The type of result object to create
  * @return mixed  `FALSE` if normal processing should continue, otherwise an object of the type $result_class
  */
 private function handleTransactionQueries(&$sql, $result_class)
 {
     // SQL Server supports transactions, but starts then with BEGIN TRANSACTION
     if ($this->type == 'mssql' && preg_match('#^\\s*(begin|start(\\s+transaction)?)\\s*#i', $sql)) {
         $sql = 'BEGIN TRANSACTION';
     }
     $begin = FALSE;
     $commit = FALSE;
     $rollback = FALSE;
     // Track transactions since most databases don't support nesting
     if (preg_match('#^\\s*(begin|start)(\\s+(transaction|work))?\\s*$#iD', $sql)) {
         if ($this->inside_transaction) {
             throw new fProgrammerException('A transaction is already in progress');
         }
         $this->inside_transaction = TRUE;
         $begin = TRUE;
     } elseif (preg_match('#^\\s*(commit)(\\s+(transaction|work))?\\s*$#iD', $sql)) {
         if (!$this->inside_transaction) {
             throw new fProgrammerException('There is no transaction in progress');
         }
         $this->inside_transaction = FALSE;
         $commit = TRUE;
     } elseif (preg_match('#^\\s*(rollback)(\\s+(transaction|work))?\\s*$#iD', $sql)) {
         if (!$this->inside_transaction) {
             throw new fProgrammerException('There is no transaction in progress');
         }
         $this->inside_transaction = FALSE;
         $rollback = TRUE;
     }
     if (!$begin && !$commit && !$rollback) {
         return FALSE;
     }
     // The PDO, OCI8, ODBC and SQLSRV extensions require special handling through methods and functions
     $is_pdo = $this->extension == 'pdo';
     $is_oci = $this->extension == 'oci8';
     $is_odbc = $this->extension == 'odbc';
     $is_sqlsrv = $this->extension == 'sqlsrv';
     if (!$is_pdo && !$is_oci && !$is_odbc && !$is_sqlsrv) {
         return FALSE;
     }
     // PDO seems to act weird if you try to start transactions through a normal query call
     if ($is_pdo) {
         try {
             $is_mssql = $this->type == 'mssql' && substr($this->database, 0, 4) != 'dsn:';
             $is_oracle = $this->type == 'oracle' && substr($this->database, 0, 4) != 'dsn:';
             if ($begin) {
                 // The SQL Server PDO object hasn't implemented transactions
                 if ($is_mssql) {
                     $this->connection->exec('BEGIN TRANSACTION');
                 } elseif ($is_oracle) {
                     $this->connection->setAttribute(PDO::ATTR_AUTOCOMMIT, FALSE);
                 } else {
                     $this->connection->beginTransaction();
                 }
             } elseif ($commit) {
                 if ($is_mssql) {
                     $this->connection->exec('COMMIT');
                 } elseif ($is_oracle) {
                     $this->connection->exec('COMMIT');
                     $this->connection->setAttribute(PDO::ATTR_AUTOCOMMIT, TRUE);
                 } else {
                     $this->connection->commit();
                 }
             } elseif ($rollback) {
                 if ($is_mssql) {
                     $this->connection->exec('ROLLBACK');
                 } elseif ($is_oracle) {
                     $this->connection->exec('ROLLBACK');
                     $this->connection->setAttribute(PDO::ATTR_AUTOCOMMIT, TRUE);
                 } else {
                     $this->connection->rollBack();
                 }
             }
         } catch (Exception $e) {
             $db_type_map = array('mssql' => 'MSSQL', 'mysql' => 'MySQL', 'oracle' => 'Oracle', 'postgresql' => 'PostgreSQL', 'sqlite' => 'SQLite');
             throw new fSQLException('%1$s error (%2$s) in %3$s', $db_type_map[$this->type], $e->getMessage(), $sql);
         }
     } elseif ($is_oci) {
         if ($commit) {
             oci_commit($this->connection);
         } elseif ($rollback) {
             oci_rollback($this->connection);
         }
     } elseif ($is_odbc) {
         if ($begin) {
             odbc_autocommit($this->connection, FALSE);
         } elseif ($commit) {
             odbc_commit($this->connection);
             odbc_autocommit($this->connection, TRUE);
         } elseif ($rollback) {
             odbc_rollback($this->connection);
             odbc_autocommit($this->connection, TRUE);
         }
//.........这里部分代码省略.........

 /**
  * Roll back transaction
  *
  * @throws VerticaException
  * @author Sergii Katrych <sergii.katrych@westwing.de>
  */
 public function rollback()
 {
     $result = odbc_rollback($this->getConnection());
     if (false === $result) {
         throw new VerticaException("Failed to RollBack transaction due to " . odbc_errormsg($this->getConnection()), odbc_error($this->getConnection()));
     }
 }

 public function rollback()
 {
     odbc_rollback($this->_con);
 }

 /**
  * Rollback queries without ending the transaction
  */
 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;
 }

 function rollback()
 {
     odbc_rollback($this->connection);
     odbc_autocommit($this->connection, true);
 }

 function RollbackTrans()
 {
     $ret = odbc_rollback($this->_connectionID);
     odbc_autocommit($this->_connectionID, true);
     return $ret;
 }

if ($rh == NULL) {
    echo odbc_errormsg($r);
    exit(1);
}
$rh = odbc_exec($r, "INSERT INTO innotable SET idx=300");
if ($rh == NULL) {
    echo odbc_errormsg($r);
    exit(1);
}
odbc_autocommit($r, false);
$rh = odbc_exec($r, "INSERT INTO innotable SET idx=500");
if ($rh == NULL) {
    echo odbc_errormsg($r);
    exit(1);
}
odbc_rollback($r);
$rh = odbc_exec($r, "SELECT * FROM innotable");
if ($rh == NULL) {
    echo odbc_errormsg($r);
    exit(1);
}
// fetch
while ($rr = odbc_fetch_array($rh)) {
    var_dump($rr);
}
$rh = odbc_exec($r, "INSERT INTO innotable SET idx=700");
if ($rh == NULL) {
    echo odbc_errormsg($r);
    exit(1);
}
odbc_commit($r);