PHP Connection::beginTransaction方法代码示例

 /**
  * drop a table - the database prefix will be prepended
  * @param string $tableName the table to drop
  */
 public static function dropTable($tableName)
 {
     $tableName = OC_Config::getValue('dbtableprefix', 'oc_') . trim($tableName);
     self::$connection->beginTransaction();
     $platform = self::$connection->getDatabasePlatform();
     $sql = $platform->getDropTableSQL($platform->quoteIdentifier($tableName));
     self::$connection->query($sql);
     self::$connection->commit();
 }

 /**
  * @param \Doctrine\DBAL\Schema\Schema $schema
  * @return bool
  */
 private function executeSchemaChange($schema)
 {
     $this->conn->beginTransaction();
     foreach ($schema->toSql($this->conn->getDatabasePlatform()) as $sql) {
         $this->conn->query($sql);
     }
     $this->conn->commit();
     return true;
 }

 /**
  * @param \Doctrine\DBAL\Schema\Schema $schema
  * @return bool
  */
 private function executeSchemaChange($schema)
 {
     $this->conn->beginTransaction();
     foreach ($schema->toSql($this->conn->getDatabasePlatform()) as $sql) {
         $this->conn->query($sql);
     }
     $this->conn->commit();
     if ($this->conn->getDatabasePlatform() instanceof SqlitePlatform) {
         \OC_DB::reconnect();
     }
     return true;
 }

 /**
  * Fix mime types
  */
 public function run()
 {
     if (!$this->connection->getDatabasePlatform() instanceof SqlitePlatform) {
         return;
     }
     $sourceSchema = $this->connection->getSchemaManager()->createSchema();
     $schemaDiff = new SchemaDiff();
     foreach ($sourceSchema->getTables() as $tableSchema) {
         $primaryKey = $tableSchema->getPrimaryKey();
         if (!$primaryKey) {
             continue;
         }
         $columnNames = $primaryKey->getColumns();
         // add a column diff for every primary key column,
         // but do not actually change anything, this will
         // force the generation of SQL statements to alter
         // those tables, which will then trigger the
         // specific SQL code from OCSqlitePlatform
         try {
             $tableDiff = new TableDiff($tableSchema->getName());
             $tableDiff->fromTable = $tableSchema;
             foreach ($columnNames as $columnName) {
                 $columnSchema = $tableSchema->getColumn($columnName);
                 $columnDiff = new ColumnDiff($columnSchema->getName(), $columnSchema);
                 $tableDiff->changedColumns[] = $columnDiff;
                 $schemaDiff->changedTables[] = $tableDiff;
             }
         } catch (SchemaException $e) {
             // ignore
         }
     }
     $this->connection->beginTransaction();
     foreach ($schemaDiff->toSql($this->connection->getDatabasePlatform()) as $sql) {
         $this->connection->query($sql);
     }
     $this->connection->commit();
 }

 /**
  * Converts legacy home storage ids in the format
  * "local::/data/dir/path/userid/" to the new format "home::userid"
  */
 public function run()
 {
     // only run once
     if ($this->config->getAppValue('core', 'repairlegacystoragesdone') === 'yes') {
         return;
     }
     $dataDir = $this->config->getSystemValue('datadirectory', \OC::$SERVERROOT . '/data/');
     $dataDir = rtrim($dataDir, '/') . '/';
     $dataDirId = 'local::' . $dataDir;
     $count = 0;
     $hasWarnings = false;
     $this->connection->beginTransaction();
     // note: not doing a direct UPDATE with the REPLACE function
     // because regexp search/extract is needed and it is not guaranteed
     // to work on all database types
     $sql = 'SELECT `id`, `numeric_id` FROM `*PREFIX*storages`' . ' WHERE `id` LIKE ?' . ' ORDER BY `id`';
     $result = $this->connection->executeQuery($sql, array($dataDirId . '%'));
     while ($row = $result->fetch()) {
         $currentId = $row['id'];
         // one entry is the datadir itself
         if ($currentId === $dataDirId) {
             continue;
         }
         try {
             if ($this->fixLegacyStorage($currentId, (int) $row['numeric_id'])) {
                 $count++;
             }
         } catch (\OC\RepairException $e) {
             $hasWarnings = true;
             $this->emit('\\OC\\Repair', 'warning', array('Could not repair legacy storage ' . $currentId . ' automatically.'));
         }
     }
     // check for md5 ids, not in the format "prefix::"
     $sql = 'SELECT COUNT(*) AS "c" FROM `*PREFIX*storages`' . ' WHERE `id` NOT LIKE \'%::%\'';
     $result = $this->connection->executeQuery($sql);
     $row = $result->fetch();
     // find at least one to make sure it's worth
     // querying the user list
     if ((int) $row['c'] > 0) {
         $userManager = \OC_User::getManager();
         // use chunks to avoid caching too many users in memory
         $limit = 30;
         $offset = 0;
         do {
             // query the next page of users
             $results = $userManager->search('', $limit, $offset);
             $storageIds = array();
             $userIds = array();
             foreach ($results as $uid => $userObject) {
                 $storageId = $dataDirId . $uid . '/';
                 if (strlen($storageId) <= 64) {
                     // skip short storage ids as they were handled in the previous section
                     continue;
                 }
                 $storageIds[$uid] = $storageId;
             }
             if (count($storageIds) > 0) {
                 // update the storages of these users
                 foreach ($storageIds as $uid => $storageId) {
                     $numericId = \OC\Files\Cache\Storage::getNumericStorageId($storageId);
                     try {
                         if (!is_null($numericId) && $this->fixLegacyStorage($storageId, (int) $numericId)) {
                             $count++;
                         }
                     } catch (\OC\RepairException $e) {
                         $hasWarnings = true;
                         $this->emit('\\OC\\Repair', 'warning', array('Could not repair legacy storage ' . $storageId . ' automatically.'));
                     }
                 }
             }
             $offset += $limit;
         } while (count($results) >= $limit);
     }
     $this->emit('\\OC\\Repair', 'info', array('Updated ' . $count . ' legacy home storage ids'));
     $this->connection->commit();
     if ($hasWarnings) {
         $this->emit('\\OC\\Repair', 'warning', array('Some legacy storages could not be repaired. Please manually fix them then re-run ./occ maintenance:repair'));
     } else {
         // if all were done, no need to redo the repair during next upgrade
         $this->config->setAppValue('core', 'repairlegacystoragesdone', 'yes');
     }
 }

 /**
  * Start a transaction
  */
 public static function beginTransaction()
 {
     self::connect();
     self::$connection->beginTransaction();
 }

 /**
  * Create an exclusive read+write lock on a table
  *
  * @param string $tableName
  * @since 9.1.0
  */
 public function lockTable($tableName)
 {
     $this->conn->beginTransaction();
     $this->conn->executeUpdate('LOCK TABLE `' . $tableName . '` IN EXCLUSIVE MODE');
 }