PHP DatabaseBase::commit方法代码示例

 /**
  * @param array $updates Array of arrays each containing two keys, 'primaryKey'
  *  and 'changes'. primaryKey must contain a map of column names to values
  *  sufficient to uniquely identify the row changes must contain a map of column
  *  names to update values to apply to the row.
  */
 public function write(array $updates)
 {
     $this->db->begin();
     foreach ($updates as $update) {
         $this->db->update($this->table, $update['changes'], $update['primaryKey'], __METHOD__);
     }
     $this->db->commit();
     wfWaitForSlaves(false, false, $this->clusterName);
 }

 /**
  * Do all the updates
  *
  * @param array $what what updates to perform
  */
 public function doUpdates($what = array('core', 'extensions', 'stats'))
 {
     global $wgVersion, $wgLocalisationCacheConf;
     $this->db->begin(__METHOD__);
     $what = array_flip($what);
     $this->skipSchema = isset($what['noschema']) || $this->fileHandle !== null;
     if (isset($what['core'])) {
         $this->runUpdates($this->getCoreUpdateList(), false);
     }
     if (isset($what['extensions'])) {
         $this->runUpdates($this->getOldGlobalUpdates(), false);
         $this->runUpdates($this->getExtensionUpdates(), true);
     }
     if (isset($what['stats'])) {
         $this->checkStats();
     }
     if (isset($what['purge'])) {
         $this->purgeCache();
         if ($wgLocalisationCacheConf['manualRecache']) {
             $this->rebuildLocalisationCache();
         }
     }
     $this->setAppliedUpdates($wgVersion, $this->updates);
     if ($this->fileHandle) {
         $this->skipSchema = false;
         $this->writeSchemaUpdateFile();
         $this->setAppliedUpdates("{$wgVersion}-schema", $this->updatesSkipped);
     }
     $this->db->commit(__METHOD__);
 }

 /**
  * Create database tables from scratch.
  *
  * @return Status
  */
 public function createTables()
 {
     $status = $this->getConnection();
     if (!$status->isOK()) {
         return $status;
     }
     $this->db->selectDB($this->getVar('wgDBname'));
     if ($this->db->tableExists('archive', __METHOD__)) {
         $status->warning('config-install-tables-exist');
         $this->enableLB();
         return $status;
     }
     $this->db->setFlag(DBO_DDLMODE);
     // For Oracle's handling of schema files
     $this->db->begin(__METHOD__);
     $error = $this->db->sourceFile($this->db->getSchemaPath());
     if ($error !== true) {
         $this->db->reportQueryError($error, 0, '', __METHOD__);
         $this->db->rollback(__METHOD__);
         $status->fatal('config-install-tables-failed', $error);
     } else {
         $this->db->commit(__METHOD__);
     }
     // Resume normal operations
     if ($status->isOk()) {
         $this->enableLB();
     }
     return $status;
 }

 /**
  * Create the tables for each extension the user enabled
  * @return Status
  */
 public function createExtensionTables()
 {
     $status = $this->getConnection();
     if (!$status->isOK()) {
         return $status;
     }
     $updater = DatabaseUpdater::newForDB($this->db);
     $extensionUpdates = $updater->getNewExtensions();
     $ourExtensions = array_map('strtolower', $this->getVar('_Extensions'));
     foreach ($ourExtensions as $ext) {
         if (isset($extensionUpdates[$ext])) {
             $this->db->begin(__METHOD__);
             $error = $this->db->sourceFile($extensionUpdates[$ext]);
             if ($error !== true) {
                 $this->db->rollback(__METHOD__);
                 $status->warning('config-install-tables-failed', $error);
             } else {
                 $this->db->commit(__METHOD__);
             }
         }
     }
     // Now run updates to create tables for old extensions
     $updater->doUpdates(array('extensions'));
     return $status;
 }

 /**
  * Merge page histories
  *
  * @param integer $id The page_id
  * @param Title $newTitle The new title
  */
 private function mergePage($row, Title $newTitle)
 {
     $id = $row->page_id;
     // Construct the WikiPage object we will need later, while the
     // page_id still exists. Note that this cannot use makeTitleSafe(),
     // we are deliberately constructing an invalid title.
     $sourceTitle = Title::makeTitle($row->page_namespace, $row->page_title);
     $sourceTitle->resetArticleID($id);
     $wikiPage = new WikiPage($sourceTitle);
     $wikiPage->loadPageData('fromdbmaster');
     $destId = $newTitle->getArticleId();
     $this->db->begin(__METHOD__);
     $this->db->update('revision', array('rev_page' => $destId), array('rev_page' => $id), __METHOD__);
     $this->db->delete('page', array('page_id' => $id), __METHOD__);
     /* Call LinksDeletionUpdate to delete outgoing links from the old title,
      * and update category counts.
      *
      * Calling external code with a fake broken Title is a fairly dubious
      * idea. It's necessary because it's quite a lot of code to duplicate,
      * but that also makes it fragile since it would be easy for someone to
      * accidentally introduce an assumption of title validity to the code we
      * are calling.
      */
     $update = new LinksDeletionUpdate($wikiPage);
     $update->doUpdate();
     $this->db->commit(__METHOD__);
     return true;
 }

 /**
  * Apply a SQL source file to the database as part of running an installation step.
  *
  * @param string $sourceFileMethod
  * @param string $stepName
  * @param string $archiveTableMustNotExist
  * @return Status
  */
 private function stepApplySourceFile($sourceFileMethod, $stepName, $archiveTableMustNotExist = false)
 {
     $status = $this->getConnection();
     if (!$status->isOK()) {
         return $status;
     }
     $this->db->selectDB($this->getVar('wgDBname'));
     if ($archiveTableMustNotExist && $this->db->tableExists('archive', __METHOD__)) {
         $status->warning("config-{$stepName}-tables-exist");
         $this->enableLB();
         return $status;
     }
     $this->db->setFlag(DBO_DDLMODE);
     // For Oracle's handling of schema files
     $this->db->begin(__METHOD__);
     $error = $this->db->sourceFile(call_user_func(array($this->db, $sourceFileMethod)));
     if ($error !== true) {
         $this->db->reportQueryError($error, 0, '', __METHOD__);
         $this->db->rollback(__METHOD__);
         $status->fatal("config-{$stepName}-tables-failed", $error);
     } else {
         $this->db->commit(__METHOD__);
     }
     // Resume normal operations
     if ($status->isOk()) {
         $this->enableLB();
     }
     return $status;
 }

 /**
  * Merge page histories
  *
  * @param integer $id The page_id
  * @param Title $newTitle The new title
  */
 private function mergePage($id, Title $newTitle)
 {
     $destId = $newTitle->getArticleId();
     $this->db->begin(__METHOD__);
     $this->db->update('revision', array('rev_page' => $destId), array('rev_page' => $id), __METHOD__);
     $this->db->delete('page', array('page_id' => $id), __METHOD__);
     // @fixme Need WikiPage::doDeleteUpdates() or similar to avoid orphan
     // rows in the links tables.
     $this->db->commit(__METHOD__);
     return true;
 }

 /**
  * Remove a batch of users
  *
  * @param DatabaseBase $dbw
  * @param int[] $batch list of user IDs to remove
  */
 private function removeBatch(DatabaseBase $dbw, array $batch)
 {
     $rows = 0;
     $dbw->begin(__METHOD__);
     // remove entries from user table
     $dbw->delete(self::USER_TABLE, ['user_id' => $batch], __METHOD__);
     $rows += $dbw->affectedRows();
     // remove entries from user_properties table
     $dbw->delete('user_properties', ['up_user' => $batch], __METHOD__);
     $rows += $dbw->affectedRows();
     $dbw->commit(__METHOD__);
     $this->info('Batch removed', ['batch' => count($batch), 'rows' => $rows]);
 }

 /**
  * Perform a cleanup for a set of wikis
  *
  * @param DatabaseBase $db database handler
  * @param string $table name of table to clean up
  * @param string $wiki_id_column table column name to use when querying for wiki ID
  * @param Array $city_ids IDs of wikis to remove from the table
  */
 private function doTableCleanup(DatabaseBase $db, $table, array $city_ids, $wiki_id_column = 'wiki_id')
 {
     $start = microtime(true);
     $db->delete($table, [$wiki_id_column => $city_ids], __METHOD__);
     $rows = $db->affectedRows();
     // just in case MW decides to start a transaction automagically
     $db->commit(__METHOD__);
     Wikia\Logger\WikiaLogger::instance()->info(__METHOD__, ['table' => $table, 'cities' => join(', ', $city_ids), 'count' => count($city_ids), 'took' => round(microtime(true) - $start, 4), 'rows' => $rows]);
     $this->output(sprintf("%s: %s - removed %d rows\n", date('Y-m-d H:i:s'), $table, $rows));
     // throttle delete queries
     if ($rows > 0) {
         sleep(5);
     }
 }

 /**
  * Do all the updates
  *
  * @param $what Array: what updates to perform
  */
 public function doUpdates($what = array('core', 'extensions', 'stats'))
 {
     global $wgVersion;
     $this->db->begin(__METHOD__);
     $what = array_flip($what);
     if (isset($what['core'])) {
         $this->runUpdates($this->getCoreUpdateList(), false);
     }
     if (isset($what['extensions'])) {
         $this->runUpdates($this->getOldGlobalUpdates(), false);
         $this->runUpdates($this->getExtensionUpdates(), true);
     }
     $this->setAppliedUpdates($wgVersion, $this->updates);
     if (isset($what['stats'])) {
         $this->checkStats();
     }
     $this->db->commit(__METHOD__);
 }

 /**
  * Do all the updates
  *
  * @param $what Array: what updates to perform
  */
 public function doUpdates($what = array('core', 'extensions', 'purge', 'stats'))
 {
     global $wgLocalisationCacheConf, $wgVersion;
     $this->db->begin(__METHOD__);
     $what = array_flip($what);
     if (isset($what['core'])) {
         $this->runUpdates($this->getCoreUpdateList(), false);
     }
     if (isset($what['extensions'])) {
         $this->runUpdates($this->getOldGlobalUpdates(), false);
         $this->runUpdates($this->getExtensionUpdates(), true);
     }
     $this->setAppliedUpdates($wgVersion, $this->updates);
     if (isset($what['stats'])) {
         $this->checkStats();
     }
     if (isset($what['purge'])) {
         $this->purgeCache();
         if ($wgLocalisationCacheConf['manualRecache']) {
             $this->rebuildLocalisationCache();
         }
     }
     $this->db->commit(__METHOD__);
 }

 public function finishWrite()
 {
     if ($this->readOnly) {
         return;
     }
     if ($this->batch) {
         $this->dbw->insert('l10n_cache', $this->batch, __METHOD__);
     }
     $this->dbw->commit(__METHOD__);
     $this->currentLang = null;
     $this->dbw = null;
     $this->batch = array();
     $this->writesDone = true;
 }

 public function finishWrite()
 {
     if ($this->readOnly) {
         return;
     } elseif (is_null($this->currentLang)) {
         throw new MWException(__CLASS__ . ': must call startWrite() before finishWrite()');
     }
     $this->dbw->begin(__METHOD__);
     try {
         $this->dbw->delete('l10n_cache', array('lc_lang' => $this->currentLang), __METHOD__);
         foreach (array_chunk($this->batch, 500) as $rows) {
             $this->dbw->insert('l10n_cache', $rows, __METHOD__);
         }
         $this->writesDone = true;
     } catch (DBQueryError $e) {
         if ($this->dbw->wasReadOnlyError()) {
             $this->readOnly = true;
             // just avoid site down time
         } else {
             throw $e;
         }
     }
     $this->dbw->commit(__METHOD__);
     $this->currentLang = null;
     $this->batch = array();
 }

 /**
  * Write (insert) the properties into the DB.
  *
  * @since 1.2
  *
  * @param Database $dbw
  *
  * @return boolean Success indicator
  */
 protected function writePropsToDB(DatabaseBase $dbw)
 {
     $success = true;
     if (array_key_exists('defaultOwnWorkLicence', $this->config) && array_key_exists('licensesOwnWork', $this->config) && !in_array($this->config['defaultOwnWorkLicence'], $this->config['licensesOwnWork'])) {
         $this->config['licensesOwnWork'][] = $this->config['defaultOwnWorkLicence'];
     }
     $dbw->begin();
     // TODO: it'd be better to serialize() arrays
     foreach ($this->config as $prop => $value) {
         $success &= $dbw->insert('uw_campaign_conf', array('cc_campaign_id' => $this->id, 'cc_property' => $prop, 'cc_value' => is_array($value) ? implode('|', $value) : $value), __METHOD__);
     }
     $dbw->commit();
     return $success;
 }

 /**
  * This function should *not* be called outside of JobQueueDB
  *
  * @param DatabaseBase $dbw
  * @param array $jobs
  * @param int $flags
  * @param string $method
  * @return boolean
  * @throws type
  */
 public function doBatchPushInternal(DatabaseBase $dbw, array $jobs, $flags, $method)
 {
     if (!count($jobs)) {
         return true;
     }
     $rowSet = array();
     // (sha1 => job) map for jobs that are de-duplicated
     $rowList = array();
     // list of jobs for jobs that are are not de-duplicated
     foreach ($jobs as $job) {
         $row = $this->insertFields($job);
         if ($job->ignoreDuplicates()) {
             $rowSet[$row['job_sha1']] = $row;
         } else {
             $rowList[] = $row;
         }
     }
     if ($flags & self::QOS_ATOMIC) {
         $dbw->begin($method);
         // wrap all the job additions in one transaction
     }
     try {
         // Strip out any duplicate jobs that are already in the queue...
         if (count($rowSet)) {
             $res = $dbw->select('job', 'job_sha1', array('job_sha1' => array_keys($rowSet), 'job_token' => ''), $method);
             foreach ($res as $row) {
                 wfDebug("Job with hash '{$row->job_sha1}' is a duplicate.\n");
                 unset($rowSet[$row->job_sha1]);
                 // already enqueued
             }
         }
         // Build the full list of job rows to insert
         $rows = array_merge($rowList, array_values($rowSet));
         // Insert the job rows in chunks to avoid slave lag...
         foreach (array_chunk($rows, 50) as $rowBatch) {
             $dbw->insert('job', $rowBatch, $method);
         }
         JobQueue::incrStats('job-insert', $this->type, count($rows));
         JobQueue::incrStats('job-insert-duplicate', $this->type, count($rowSet) + count($rowList) - count($rows));
     } catch (DBError $e) {
         if ($flags & self::QOS_ATOMIC) {
             $dbw->rollback($method);
         }
         throw $e;
     }
     if ($flags & self::QOS_ATOMIC) {
         $dbw->commit($method);
     }
     $this->cache->set($this->getCacheKey('empty'), 'false', JobQueueDB::CACHE_TTL_LONG);
     return true;
 }