PHP Connection::rollback方法代码示例

 public function testTransactionRollback()
 {
     $this->createTable();
     $this->connection->beginTransaction();
     $this->connection->query("INSERT INTO cat (name, colour) VALUES (?, ?)", array('Nennek', 'black'));
     $this->connection->rollback();
     $statement = $this->connection->query("SELECT count(*) AS c FROM cat");
     $row = $this->connection->fetch($statement);
     $count = array_shift($row);
     $this->assertEquals(2, $count);
 }

function install_procedure(Connection $connection, $procedure)
{
    $result = $connection->excecute($procedure);
    $sql = $connection->getLastQuery();
    if (!$result) {
        $connection->rollback();
        error($sql);
        return false;
    }
    ok($sql);
    return true;
}

 public function testRollback()
 {
     $exch = DriverTestManager::getExchange('RecordCount');
     $count_sql = $exch->getSql();
     $rs = $this->conn->executeQuery($count_sql, ResultSet::FETCHMODE_NUM);
     $rs->next();
     $total = $rs->getInt(1);
     // $this->assertEquals((int) $exch->getResult(), $total);
     $this->conn->setAutoCommit(false);
     // not sure exactly how to test this yet ...
     $exch = DriverTestManager::getExchange('ConnectionTest.setAutoCommit.DELTRAN1');
     $deleted1 = $this->conn->executeUpdate($exch->getSql());
     $exch = DriverTestManager::getExchange('ConnectionTest.setAutoCommit.DELTRAN2');
     $deleted2 = $this->conn->executeUpdate($exch->getSql());
     $this->conn->rollback();
     // compare the actual total w/ what we expect
     $rs = $this->conn->executeQuery($count_sql, ResultSet::FETCHMODE_NUM);
     $rs->next();
     $new_actual_total = $rs->getInt(1);
     $this->assertEquals($total, $new_actual_total, 0, "Failed to find correct (same) num of records in table after rollback().");
     $this->conn->setAutoCommit(true);
 }

    /**
     * Roll back a transaction in databases that support transactions.
     * It also releases the connection. In databases that do not support
     * transactions, this method will log the attempt and release the
     * connection.
     *
     * @param Connection $con The Connection for the transaction.
     * @return void
     * @throws PropelException
     */
    public static function rollback($con)
    {
        if ($con === null) {
            throw new PropelException(
                    "Connection object was null. "
                    . "This could be due to a misconfiguration. "
                    . "Check the logs and Propel properties "
                    . "to better determine the cause.");
        }

        try {
            if ($con->getAutoCommit() === false) {
                $con->rollback();
                $con->setAutoCommit(true);
            }
        } catch (SQLException $e) {
            Propel::log(
                    "An attempt was made to rollback a transaction "
                    . "but the database did not allow the operation to be "
                    . "rolled back: " . $e->getMessage(), Propel::LOG_ERR);
            throw new PropelException($e);
        }
    }

 /**
  * @see Connection::rollback()
  */
 public function rollback()
 {
     $this->log("Rolling back transaction.");
     return $this->childConnection->rollback();
 }

	/**
	 * Rollback transaction.
	 */
	public function rollback() {
		$this->connection->rollback();
	}

 /**
  * Execute this migration version up or down and and return the SQL.
  *
  * @param string $direction   The direction to execute the migration.
  * @param string $dryRun      Whether to not actually execute the migration SQL and just do a dry run.
  * @return array $sql
  * @throws Exception when migration fails
  */
 public function execute($direction, $dryRun = false)
 {
     $this->_sql = array();
     $this->_connection->beginTransaction();
     try {
         $start = microtime(true);
         $this->_state = self::STATE_PRE;
         $fromSchema = $this->_sm->createSchema();
         $this->_migration->{'pre' . ucfirst($direction)}($fromSchema);
         if ($direction === 'up') {
             $this->_outputWriter->write("\n" . sprintf('  <info>++</info> migrating <comment>%s</comment>', $this->_version) . "\n");
         } else {
             $this->_outputWriter->write("\n" . sprintf('  <info>--</info> reverting <comment>%s</comment>', $this->_version) . "\n");
         }
         $this->_state = self::STATE_EXEC;
         $toSchema = clone $fromSchema;
         $this->_migration->{$direction}($toSchema);
         $this->addSql($fromSchema->getMigrateToSql($toSchema, $this->_platform));
         if ($dryRun === false) {
             if ($this->_sql) {
                 $count = count($this->_sql);
                 foreach ($this->_sql as $query) {
                     $this->_outputWriter->write('     <comment>-></comment> ' . $query);
                     $this->_connection->executeQuery($query);
                 }
             } else {
                 $this->_outputWriter->write(sprintf('<error>Migration %s was executed but did not result in any SQL statements.</error>', $this->_version));
             }
             if ($direction === 'up') {
                 $this->markMigrated();
             } else {
                 $this->markNotMigrated();
             }
         } else {
             foreach ($this->_sql as $query) {
                 $this->_outputWriter->write('     <comment>-></comment> ' . $query);
             }
         }
         $this->_state = self::STATE_POST;
         $this->_migration->{'post' . ucfirst($direction)}($toSchema);
         $end = microtime(true);
         $this->_time = round($end - $start, 2);
         if ($direction === 'up') {
             $this->_outputWriter->write(sprintf("\n  <info>++</info> migrated (%ss)", $this->_time));
         } else {
             $this->_outputWriter->write(sprintf("\n  <info>--</info> reverted (%ss)", $this->_time));
         }
         $this->_connection->commit();
         return $this->_sql;
     } catch (SkipMigrationException $e) {
         $this->_connection->rollback();
         // now mark it as migrated
         if ($direction === 'up') {
             $this->markMigrated();
         } else {
             $this->markNotMigrated();
         }
         $this->_outputWriter->write(sprintf("\n  <info>SS</info> skipped (Reason: %s)", $e->getMessage()));
     } catch (\Exception $e) {
         $this->_outputWriter->write(sprintf('<error>Migration %s failed during %s. Error %s</error>', $this->_version, $this->getExecutionState(), $e->getMessage()));
         $this->_connection->rollback();
         $this->_state = self::STATE_NONE;
         throw $e;
     }
     $this->_state = self::STATE_NONE;
 }

 public function rollback()
 {
     if ($this->_connection) {
         $this->_connection->rollback();
     }
 }

 /**
  * @see Connection::rollback()
  */
 public function rollback()
 {
     krumo('DBArrayConnection rollback ');
     die;
     $this->log("Rolling back transaction.");
     return $this->childConnection->rollback();
 }

function importDataGuru($inputFileName, $idSekolah)
{
    try {
        /**  Identify the type of $inputFileName  **/
        $inputFileType = PHPExcel_IOFactory::identify($inputFileName);
        /**  Create a new Reader of the type that has been identified  **/
        $objReader = PHPExcel_IOFactory::createReader($inputFileType);
        /**  Load $inputFileName to a PHPExcel Object  **/
        $objReader->setReadDataOnly(true);
        $objPHPExcel = $objReader->load($inputFileName);
    } catch (Exception $e) {
        die('Error loading file "' . pathinfo($inputFileName, PATHINFO_BASENAME) . '": ' . $e->getMessage());
    }
    $worksheets;
    $conn;
    $nameSheet;
    $noRow = 0;
    try {
        $conn = new Connection();
        $conn->beginTransaction();
        $worksheets = $objPHPExcel->getAllSheets();
        $idGuru;
        foreach ($worksheets as $worksheet) {
            $nameSheet = $worksheet->getTitle();
            //guru
            $noRow = 2;
            while (true) {
                $username = $worksheet->getCell('B' . $noRow)->getCalculatedValue();
                $password = $worksheet->getCell('C' . $noRow)->getCalculatedValue();
                $nip = $worksheet->getCell('D' . $noRow)->getCalculatedValue();
                $nama = $worksheet->getCell('E' . $noRow)->getCalculatedValue();
                if ($username == null) {
                    break;
                }
                $idGuru = $conn->setGuru($nip, $nama, null, null, null, null, null, null, null, $username, $password, $idSekolah, null);
                //$idGuru=$conn->setGuru($nip, $nama, $tempatLahir, $tglLahir, $jk, $alamat, $telp, $hp, $email, $username, $password, $idSekolah, $foto);
                $noRow++;
            }
        }
        $conn->commit();
        echo 'Data import succesfully';
    } catch (Exception $e) {
        $conn->rollback();
        die('Error in Sheet ' . $nameSheet . ' row ' . $noRow . ' : ' . $e->getMessage());
    }
}