function sql_db($sqlserver, $sqluser, $sqlpassword, $database, $persistency = true)
 {
     $mtime = microtime();
     $mtime = explode(" ", $mtime);
     $mtime = $mtime[1] + $mtime[0];
     $starttime = $mtime;
     $this->persistency = $persistency;
     $this->user = $sqluser;
     $this->password = $sqlpassword;
     $this->dbname = $database;
     $this->server = $sqlserver;
     if ($this->persistency) {
         $this->db_connect_id = odbc_pconnect($this->server, "", "");
     } else {
         $this->db_connect_id = odbc_connect($this->server, "", "");
     }
     if ($this->db_connect_id) {
         @odbc_autocommit($this->db_connect_id, off);
         $mtime = microtime();
         $mtime = explode(" ", $mtime);
         $mtime = $mtime[1] + $mtime[0];
         $endtime = $mtime;
         $this->sql_time += $endtime - $starttime;
         return $this->db_connect_id;
     } else {
         $mtime = microtime();
         $mtime = explode(" ", $mtime);
         $mtime = $mtime[1] + $mtime[0];
         $endtime = $mtime;
         $this->sql_time += $endtime - $starttime;
         return false;
     }
 }

 function sql_db($sqlserver, $sqluser, $sqlpassword, $database, $persistency = true)
 {
     $this->persistency = $persistency;
     $this->user = $sqluser;
     $this->password = $sqlpassword;
     $this->dbname = $database;
     $this->server = $sqlserver;
     if ($this->persistency) {
         $this->db_connect_id = odbc_pconnect($this->server, "", "");
     } else {
         $this->db_connect_id = odbc_connect($this->server, "", "");
     }
     if ($this->db_connect_id) {
         @odbc_autocommit($this->db_connect_id, off);
         return $this->db_connect_id;
     } else {
         return false;
     }
 }

 /**
  * Connection to the database
  *
  */
 public function __construct()
 {
     parent::__construct();
     if ($this->table == '') {
         $this->table = $this->table_prefix . str_replace('Model', '', get_class($this));
     }
     require FRAMEWORK . DS . 'conf' . DS . 'datastore.php';
     $config = $datastore[$this->datastore];
     if (!isset(self::$connection[$this->datastore])) {
         self::$connection[$this->datastore] = odbc_connect('DRIVER={SQL Server};SERVER=' . $config['host'] . ';DATABASE=' . $config['db'] . '', $config['user'], $config['password']);
         if (!self::$connection[$this->datastore]) {
             throw new connectException('Could not connect to the datastore: ' . odbc_errormsg());
         }
         if (!odbc_autocommit(self::$connection[$this->datastore], false)) {
             throw new connectException('unable to connect: ' . odbc_errormsg());
         }
     }
     $this->con =& self::$connection[$this->datastore];
 }

 /**
  * 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 Transaction.
  *
  * @return bool
  */
 protected function _trans_rollback()
 {
     if (odbc_rollback($this->conn_id)) {
         odbc_autocommit($this->conn_id, true);
         return true;
     }
     return false;
 }

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

 /**
  * 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;
 }

# $Id$
# Sample PHP script accessing HyperSQL through the ODBC extension module.
# (Therefore, you need to have the PHP ODBC module installed).
# This test HyperSQL client uses the ODBC DSN "tstdsn" to connect up to a
# HyperSQL server.  Just configure your own DSN to use the HyperSQL ODBC
# driver, specifying the HyperSQL server host name, database name, user,
# password, etc.
# Author:  Blaine Simpson  (blaine dot simpson at admc dot com)
# Empty strings for the username or password parameter here will defer
# to the ODBC manager for those values.  I.e. the blanks here do not mean to
# send blanks to the database server.
$conn_id = odbc_connect('tstdsn', '', '');
if (!$conn_id) {
    exit('Connection Failed: ' . $conn_id . "\n");
}
if (!odbc_autocommit($conn_id, FALSE)) {
    exit("Failed to turn off AutoCommit mode\n");
}
if (!odbc_exec($conn_id, "DROP TABLE tsttbl IF EXISTS")) {
    exit("DROP command failed\n");
}
if (!odbc_exec($conn_id, "CREATE TABLE tsttbl(\n    id BIGINT generated BY DEFAULT AS IDENTITY,\n    vc VARCHAR(20),\n    entrytime TIMESTAMP DEFAULT current_timestamp NOT NULL\n)")) {
    exit("CREATE TABLE command failed\n");
}
# First do a non-parameterized insert
if (!odbc_exec($conn_id, "INSERT INTO tsttbl(id, vc) VALUES(1, 'one')")) {
    exit("Insertion of first row failed\n");
}
# Now parameterized inserts
$stmt = odbc_prepare($conn_id, "INSERT INTO tsttbl(id, vc) VALUES(?, ?)");
if (!$stmt) {

echo "resource? " . is_resource($r) . "\n";
if (!$r) {
    echo odbc_errormsg();
    exit(1);
}
$rh = odbc_exec($r, "CREATE TABLE IF NOT EXISTS innotable ( idx INT UNSIGNED NOT NULL ) TYPE=InnoDB");
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);
}

 /**
  * Is in transaction?
  * @return bool
  */
 public function inTransaction()
 {
     return !odbc_autocommit($this->connection);
 }

 function AutoCommitTransactions($auto_commit)
 {
     if (!$this->auto_commit == !$auto_commit) {
         return 1;
     }
     if (!isset($this->supported["Transactions"])) {
         return $this->SetError("Auto-commit transactions", "transactions are not supported");
     }
     if ($this->connection && !@odbc_autocommit($this->connection, $auto_commit)) {
         return $this->SetODBCError("Auto-commit transactions", "Could not set transaction auto-commit mode to {$auto_commit}", $php_errormsg);
     }
     $this->auto_commit = $auto_commit;
     return 1;
 }

 /**
  * Commit transaction and re-enable autocommit mode
  *
  * @throws VerticaException
  * @author Sergii Katrych <[email protected]>
  */
 public function commit()
 {
     $result = odbc_commit($this->getConnection());
     if (false === $result) {
         throw new VerticaException("Failed to commit transaction due to " . odbc_errormsg($this->getConnection()), odbc_error($this->getConnection()));
     }
     $result = odbc_autocommit($this->getConnection(), true);
     if (false === $result) {
         throw new VerticaException("Failed to re-enable autocommit to get out of transactions mode. " . odbc_errormsg($this->getConnection()), odbc_error($this->getConnection()));
     }
 }

<?php

dirname(__FILE__);
odbc_autocommit($this->conn_id, FALSE);
session_set_save_handler($class, TRUE);
substr(__FILE__, 0, 5);
count($sql, true);
echo 0, 1.1, false, CONSTANTE, ns\Name;
print <<<HHH
HHH;
sprintf(<<<HHHH
HHHH
, $a);
//dirname(__FILE__) =>  __DIR__

 public function after_connect()
 {
     odbc_autocommit($this->_con, false);
 }

 /**
  * End a transaction by either committing changes made, or reverting them
  */
 public function endTransaction($commit)
 {
     if ($commit) {
         $result = $this->commit();
     } else {
         $result = $this->rollback();
     }
     switch ($this->mode) {
         case "mysql":
             if (!$this->server->autocommit(true)) {
                 $result = false;
             }
             break;
         case "postgres":
             $result = $this->query("SET AUTOCOMMIT = ON");
             break;
         case "redshift":
             # Do nothing, and use the result from the commit/rollback
             break;
         case "odbc":
             if (!odbc_autocommit($this->server, true)) {
                 $result = false;
             }
             break;
         default:
             throw new \Exception("endTransaction() not supported in this mode (" . $this->mode . ")");
     }
     if (!$result) {
         $this->error();
     }
     $this->transaction = false;
     return true;
 }

 public function autocommit($onOff)
 {
     odbc_autocommit($this->_lnk, $onOff);
 }

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

DibiDriverException(odbc_errormsg($this->connection).' '.odbc_error($this->connection));}odbc_autocommit($this->connection,TRUE);}function
inTransaction(){return!odbc_autocommit($this->connection);}function