function Rollback() { $this->DoConnect(); odbc_rollback($this->db_Conn); //$this->Query("rollback", false, "FILE: ".__FILE__."<br> LINE: ".__LINE__); odbc_autocommit($this->db_Conn, true); }
/** * 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); } } elseif ($is_sqlsrv) { if ($begin) { sqlsrv_begin_transaction($this->connection); } elseif ($commit) { sqlsrv_commit($this->connection); } elseif ($rollback) { sqlsrv_rollback($this->connection); } } $result = new $result_class($this); $result->setSQL($sql); $result->setResult(TRUE); return $result; }
/** * Roll back transaction * * @throws VerticaException * @author Sergii Katrych <*****@*****.**> */ 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);
function RollbackTransaction() { if ($this->auto_commit) { return $this->SetError("Rollback transaction", "transactions can not be rolled back when changes are auto commited"); } if (!@odbc_rollback($this->connection)) { return $this->SetODBCError("Rollback transaction", "Could not rollback the current transaction", $php_errormsg); } return 1; }
public function transRollback() { $rollback = odbc_rollback($this->connect); odbc_autocommit($this->connect, true); return $rollback; }
/** * Rollback Transaction. * * @return bool */ protected function _trans_rollback() { if (odbc_rollback($this->conn_id)) { odbc_autocommit($this->conn_id, true); return true; } return false; }
function sql_query($query = "", $transaction = FALSE) { if ($query != "") { $this->num_queries++; if ($transaction == BEGIN_TRANSACTION && !$this->in_transaction) { if (!odbc_autocommit($this->db_connect_id, false)) { return false; } $this->in_transaction = TRUE; } if (preg_match("/^SELECT(.*?)(LIMIT ([0-9]+)[, ]*([0-9]+)*)?\$/s", $query, $limits)) { $query = $limits[1]; if (!empty($limits[2])) { $row_offset = $limits[4] ? $limits[3] : ""; $num_rows = $limits[4] ? $limits[4] : $limits[3]; $query = "TOP " . ($row_offset + $num_rows) . $query; } $this->result = odbc_exec($this->db_connect_id, "SELECT {$query}"); if ($this->result) { if (empty($this->field_names[$this->result])) { for ($i = 1; $i < odbc_num_fields($this->result) + 1; $i++) { $this->field_names[$this->result][] = odbc_field_name($this->result, $i); $this->field_types[$this->result][] = odbc_field_type($this->result, $i); } } $this->current_row[$this->result] = 0; $this->result_rowset[$this->result] = array(); $row_outer = isset($row_offset) ? $row_offset + 1 : 1; $row_outer_max = isset($num_rows) ? $row_offset + $num_rows + 1 : 1000000000.0; $row_inner = 0; while (odbc_fetch_row($this->result, $row_outer) && $row_outer < $row_outer_max) { for ($j = 0; $j < count($this->field_names[$this->result]); $j++) { $this->result_rowset[$this->result][$row_inner][$this->field_names[$this->result][$j]] = stripslashes(odbc_result($this->result, $j + 1)); } $row_outer++; $row_inner++; } $this->num_rows[$this->result] = count($this->result_rowset[$this->result]); } } else { if (eregi("^INSERT ", $query)) { $this->result = odbc_exec($this->db_connect_id, $query); if ($this->result) { $result_id = odbc_exec($this->db_connect_id, "SELECT @@IDENTITY"); if ($result_id) { if (odbc_fetch_row($result_id)) { $this->next_id[$this->db_connect_id] = odbc_result($result_id, 1); $this->affected_rows[$this->db_connect_id] = odbc_num_rows($this->result); } } } } else { $this->result = odbc_exec($this->db_connect_id, $query); if ($this->result) { $this->affected_rows[$this->db_connect_id] = odbc_num_rows($this->result); } } } if (!$this->result) { if ($this->in_transaction) { odbc_rollback($this->db_connect_id); odbc_autocommit($this->db_connect_id, true); $this->in_transaction = FALSE; } return false; } if ($transaction == END_TRANSACTION && $this->in_transaction) { $this->in_transaction = FALSE; if (!odbc_commit($this->db_connect_id)) { odbc_rollback($this->db_connect_id); odbc_autocommit($this->db_connect_id, true); return false; } odbc_autocommit($this->db_connect_id, true); } odbc_free_result($this->result); return $this->result; } else { if ($transaction == END_TRANSACTION && $this->in_transaction) { $this->in_transaction = FALSE; if (!@odbc_commit($this->db_connect_id)) { odbc_rollback($this->db_connect_id); odbc_autocommit($this->db_connect_id, true); return false; } odbc_autocommit($this->db_connect_id, true); } return true; } }
/** * Roll back (undo) the current transaction. * @throws SQLException * @return void */ protected function rollbackTrans() { if ($this->adapter->supportsTransactions()) { $result = @odbc_rollback($this->dblink); if (!$result) { throw new SQLException('Could not rollback transaction', $this->nativeError()); } @odbc_autocommit($this->dblink, true); if (odbc_error($this->dblink) == 'S1C00') { throw new SQLException('Could not rollback transaction (autocommit failed)', $this->nativeError()); } } }
function rollback() { if (!@odbc_rollback($this->connection)) { return $this->odbcRaiseError(); } return DB_OK; }
/** * Rollback changes in a transaction. * @return void * @throws DibiDriverException */ public function rollback() { if (!odbc_rollback($this->connection)) { $this->throwException(); } odbc_autocommit($this->connection, TRUE); }
/** * Rollback changes in a transaction. * @param string optinal savepoint name * @return void * @throws DibiDriverException */ public function rollback($savepoint = NULL) { if (!odbc_rollback($this->connection)) { throw new DibiDriverException(odbc_errormsg($this->connection) . ' ' . odbc_error($this->connection)); } odbc_autocommit($this->connection, TRUE); }
function sql_transaction($status = 'begin') { switch ($status) { case 'begin': $result = @odbc_autocommit($this->db_connect_id, false); $this->transaction = true; break; case 'commit': $result = @odbc_commit($this->db_connect_id); @odbc_autocommit($this->db_connect_id, true); $this->transaction = false; if (!$result) { @odbc_rollback($this->db_connect_id); @odbc_autocommit($this->db_connect_id, true); } break; case 'rollback': $result = @odbc_rollback($this->db_connect_id); @odbc_autocommit($this->db_connect_id, true); $this->transaction = false; break; default: $result = true; } return $result; }