/**
  * Delete one or more revisions from the database
  * Do this inside a transaction
  *
  * @param array $id Array of revision id values
  * @param DatabaseBase $dbw DatabaseBase class (needs to be a master)
  */
 private function deleteRevs($id, &$dbw)
 {
     if (!is_array($id)) {
         $id = array($id);
     }
     $dbw->delete('revision', array('rev_id' => $id), __METHOD__);
 }

 /**
  * @param DatabaseBase $db
  * @return mixed
  */
 public function doQuery($db)
 {
     $ids = array_map('intval', $this->ids);
     $queryInfo = array('tables' => array('revision', 'user'), 'fields' => array_merge(Revision::selectFields(), Revision::selectUserFields()), 'conds' => array('rev_page' => $this->title->getArticleID(), 'rev_id' => $ids), 'options' => array('ORDER BY' => 'rev_id DESC'), 'join_conds' => array('page' => Revision::pageJoinCond(), 'user' => Revision::userJoinCond()));
     ChangeTags::modifyDisplayQuery($queryInfo['tables'], $queryInfo['fields'], $queryInfo['conds'], $queryInfo['join_conds'], $queryInfo['options'], '');
     return $db->select($queryInfo['tables'], $queryInfo['fields'], $queryInfo['conds'], __METHOD__, $queryInfo['options'], $queryInfo['join_conds']);
 }

 /**
  * @param ResultWrapper $res
  * @param DatabaseBase $dbw
  * @return null|int
  */
 function convertOptionBatch($res, $dbw)
 {
     $id = null;
     foreach ($res as $row) {
         $this->mConversionCount++;
         $insertRows = array();
         foreach (explode("\n", $row->user_options) as $s) {
             $m = array();
             if (!preg_match("/^(.[^=]*)=(.*)\$/", $s, $m)) {
                 continue;
             }
             // MW < 1.16 would save even default values. Filter them out
             // here (as in User) to avoid adding many unnecessary rows.
             $defaultOption = User::getDefaultOption($m[1]);
             if (is_null($defaultOption) || $m[2] != $defaultOption) {
                 $insertRows[] = array('up_user' => $row->user_id, 'up_property' => $m[1], 'up_value' => $m[2]);
             }
         }
         if (count($insertRows)) {
             $dbw->insert('user_properties', $insertRows, __METHOD__, array('IGNORE'));
         }
         $dbw->update('user', array('user_options' => ''), array('user_id' => $row->user_id), __METHOD__);
         $id = $row->user_id;
     }
     return $id;
 }

 public function updateRevision($columnPrefix, DatabaseBase $dbw, $continue = null)
 {
     $rows = $dbw->select('flow_revision', array('rev_id', 'rev_type'), array('rev_id > ' . $dbw->addQuotes($continue), "{$columnPrefix}_id > 0", "{$columnPrefix}_ip IS NOT NULL"), __METHOD__, array('LIMIT' => $this->mBatchSize, 'ORDER BY' => 'rev_id'));
     $ids = $objs = array();
     foreach ($rows as $row) {
         $id = UUID::create($row->rev_id);
         $type = self::$types[$row->rev_type];
         $om = $this->storage->getStorage($type);
         $obj = $om->get($id);
         if ($obj) {
             $om->merge($obj);
             $ids[] = $row->rev_id;
             $objs[] = $obj;
         } else {
             $this->error(__METHOD__ . ": Failed loading {$type}: " . $id->getAlphadecimal());
         }
     }
     if (!$ids) {
         return null;
     }
     $dbw->update('flow_revision', array("{$columnPrefix}_ip" => null), array('rev_id' => $ids), __METHOD__);
     foreach ($objs as $obj) {
         $this->storage->cachePurge($obj);
     }
     $this->completeCount += count($ids);
     return end($ids);
 }

 public function refreshBatch(DatabaseBase $dbr, UUID $continue, $countableActions, UUID $stop)
 {
     $rows = $dbr->select('flow_revision', array('rev_id', 'rev_user_id'), array('rev_id > ' . $dbr->addQuotes($continue->getBinary()), 'rev_id <= ' . $dbr->addQuotes($stop->getBinary()), 'rev_user_id > 0', 'rev_user_wiki' => wfWikiID(), 'rev_change_type' => $countableActions), __METHOD__, array('ORDER BY' => 'rev_id ASC', 'LIMIT' => $this->mBatchSize));
     // end of data
     if (!$rows || $rows->numRows() === 0) {
         return false;
     }
     foreach ($rows as $row) {
         // User::incEditCount only allows for edit count to be increased 1
         // at a time. It'd be better to immediately be able to increase the
         // edit count by the exact number it should be increased with, but
         // I'd rather re-use existing code, especially in a run-once script,
         // where performance is not the most important thing ;)
         $user = User::newFromId($row->rev_user_id);
         $user->incEditCount();
         // save updates so we can print them when the script is done running
         if (!isset($this->updates[$user->getId()])) {
             $this->updates[$user->getId()] = 0;
         }
         $this->updates[$user->getId()]++;
         // set value for next batch to continue at
         $continue = $row->rev_id;
     }
     return UUID::create($continue);
 }

 /**
  * @see SMWDescription::getSQLCondition
  *
  * FIXME: store specific code should be in the store component
  *
  * @since 0.6
  * 
  * @param string $tableName
  * @param array $fieldNames
  * @param DatabaseBase $dbs
  * 
  * @return boolean
  */
 public function getSQLCondition($tableName, array $fieldNames, DatabaseBase $dbs)
 {
     $dataItem = $this->getDataItem();
     // Only execute the query when the description's type is geographical coordinates,
     // the description is valid, and the near comparator is used.
     if ($dataItem instanceof SMWDIGeoCoord) {
         switch ($this->getComparator()) {
             case SMW_CMP_EQ:
                 $comparator = '=';
                 break;
             case SMW_CMP_LEQ:
                 $comparator = '<=';
                 break;
             case SMW_CMP_GEQ:
                 $comparator = '>=';
                 break;
             case SMW_CMP_NEQ:
                 $comparator = '!=';
                 break;
             default:
                 return false;
         }
         $lat = $dbs->addQuotes($dataItem->getLatitude());
         $lon = $dbs->addQuotes($dataItem->getLongitude());
         $conditions = array();
         $conditions[] = "{$tableName}.{$fieldNames['1']} {$comparator} {$lat}";
         $conditions[] = "{$tableName}.{$fieldNames['2']} {$comparator} {$lon}";
         return implode(' AND ', $conditions);
     }
     return false;
 }

 function updateUserWikiCount(DatabaseBase $db, $userId, $wikiCount)
 {
     $res = $db->update("webmaster_user_accounts", array("wikis_number" => $wikiCount), array("user_id" => $userId));
     if (!$res) {
         throw new Exception("Failed to update User id=" . $userId . " count = " . $wikiCount);
     }
 }

 /**
  * @param DatabaseBase $db
  * @return mixed
  */
 public function doQuery($db)
 {
     $ids = array_map('intval', $this->ids);
     $live = $db->select(array('revision', 'page', 'user'), array_merge(Revision::selectFields(), Revision::selectUserFields()), array('rev_page' => $this->title->getArticleID(), 'rev_id' => $ids), __METHOD__, array('ORDER BY' => 'rev_id DESC'), array('page' => Revision::pageJoinCond(), 'user' => Revision::userJoinCond()));
     if ($live->numRows() >= count($ids)) {
         // All requested revisions are live, keeps things simple!
         return $live;
     }
     // Check if any requested revisions are available fully deleted.
     $archived = $db->select(array('archive'), Revision::selectArchiveFields(), array('ar_rev_id' => $ids), __METHOD__, array('ORDER BY' => 'ar_rev_id DESC'));
     if ($archived->numRows() == 0) {
         return $live;
     } elseif ($live->numRows() == 0) {
         return $archived;
     } else {
         // Combine the two! Whee
         $rows = array();
         foreach ($live as $row) {
             $rows[$row->rev_id] = $row;
         }
         foreach ($archived as $row) {
             $rows[$row->ar_rev_id] = $row;
         }
         krsort($rows);
         return new FakeResultWrapper(array_values($rows));
     }
 }

 /**
  * Lock the appropriate tables for the script
  * @param DatabaseBase $db
  * @param string $extraTable The name of any extra tables to lock (eg: text)
  */
 private function lockTables($db, $extraTable = [])
 {
     $tbls = ['page', 'revision', 'redirect'];
     if ($extraTable) {
         $tbls = array_merge($tbls, $extraTable);
     }
     $db->lockTables([], $tbls, __METHOD__, false);
 }

 /**
  * @param DatabaseBase $db
  * @return mixed
  */
 public function doQuery($db)
 {
     $timestamps = array();
     foreach ($this->ids as $id) {
         $timestamps[] = $db->timestamp($id);
     }
     return $db->select('archive', Revision::selectArchiveFields(), array('ar_namespace' => $this->title->getNamespace(), 'ar_title' => $this->title->getDBkey(), 'ar_timestamp' => $timestamps), __METHOD__, array('ORDER BY' => 'ar_timestamp DESC'));
 }

 /**
  * @param DatabaseBase $db
  * @return mixed
  */
 public function doQuery($db)
 {
     $archiveNames = array();
     foreach ($this->ids as $timestamp) {
         $archiveNames[] = $timestamp . '!' . $this->title->getDBkey();
     }
     return $db->select('oldimage', OldLocalFile::selectFields(), array('oi_name' => $this->title->getDBkey(), 'oi_archive_name' => $archiveNames), __METHOD__, array('ORDER BY' => 'oi_timestamp DESC'));
 }

 /**
  * @param DatabaseBase $db
  * @return mixed
  */
 public function doQuery($db)
 {
     $ids = array_map('intval', $this->ids);
     $queryInfo = DatabaseLogEntry::getSelectQueryData();
     $queryInfo['conds'] += array('log_id' => $ids);
     $queryInfo['options'] += array('ORDER BY' => 'log_id DESC');
     ChangeTags::modifyDisplayQuery($queryInfo['tables'], $queryInfo['fields'], $queryInfo['conds'], $queryInfo['join_conds'], $queryInfo['options'], '');
     return $db->select($queryInfo['tables'], $queryInfo['fields'], $queryInfo['conds'], __METHOD__, $queryInfo['options'], $queryInfo['join_conds']);
 }

 /**
  * May throw a database error if, say, the server dies during query.
  * @param DatabaseBase $db
  * @param int $id The old_id
  * @return string
  */
 private function doGetText($db, $id)
 {
     $id = intval($id);
     $row = $db->selectRow('text', ['old_text', 'old_flags'], ['old_id' => $id], __METHOD__);
     $text = Revision::getRevisionText($row);
     if ($text === false) {
         return false;
     }
     return $text;
 }

 public static function buildPostInExpr(\DatabaseBase $db, array $arr)
 {
     $range = '';
     foreach ($arr as $post) {
         if ($range) {
             $range .= ',';
         }
         $range .= $db->addQuotes($post->id->getBin());
     }
     return ' IN(' . $range . ')';
 }

 /**
  * Get temp user accounts
  *
  * - check if these accounts are really temp ones
  * - do not remove accounts with password set (122 of them)
  *
  * @param DatabaseBase $db
  * @return int[]
  */
 protected function getAccountsToRemove(DatabaseBase $db)
 {
     $res = $db->select(self::USER_TABLE, ['user_id', 'user_name'], ['user_name ' . $db->buildLike(self::TEMPUSER_PREFIX, $db->anyString()), 'user_password' => ''], __METHOD__);
     $users = [];
     while ($user = $res->fetchObject()) {
         // check if this is really a temp user: "TempUser" + <user ID>
         if ($user->user_name === self::TEMPUSER_PREFIX . $user->user_id) {
             $users[] = intval($user->user_id);
         } else {
             $this->output(sprintf(" > skipped %s (#%d)\n", $user->user_name, $user->user_id));
         }
     }
     return $users;
 }

 /**
  * Cache page existence for performance
  *
  * @param DatabaseBase $db
  * @param ResultWrapper $res
  */
 function preprocessResults($db, $res)
 {
     $batch = new LinkBatch();
     foreach ($res as $row) {
         $batch->add($row->namespace, $row->title);
         $batch->addObj($this->getRedirectTarget($row));
     }
     $batch->execute();
     // Back to start for display
     if ($res->numRows() > 0) {
         // If there are no rows we get an error seeking.
         $db->dataSeek($res, 0);
     }
 }

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

 protected function buildUpdateCondition(DatabaseBase $dbw)
 {
     $rcNew = $dbw->addQuotes(RC_NEW);
     $rcSrcNew = $dbw->addQuotes(RecentChange::SRC_NEW);
     $rcEdit = $dbw->addQuotes(RC_EDIT);
     $rcSrcEdit = $dbw->addQuotes(RecentChange::SRC_EDIT);
     $rcLog = $dbw->addQuotes(RC_LOG);
     $rcSrcLog = $dbw->addQuotes(RecentChange::SRC_LOG);
     $rcExternal = $dbw->addQuotes(RC_EXTERNAL);
     $rcSrcExternal = $dbw->addQuotes(RecentChange::SRC_EXTERNAL);
     return "rc_source = CASE\n\t\t\t\t\tWHEN rc_type = {$rcNew} THEN {$rcSrcNew}\n\t\t\t\t\tWHEN rc_type = {$rcEdit} THEN {$rcSrcEdit}\n\t\t\t\t\tWHEN rc_type = {$rcLog} THEN {$rcSrcLog}\n\t\t\t\t\tWHEN rc_type = {$rcExternal} THEN {$rcSrcExternal}\n\t\t\t\t\tELSE ''\n\t\t\t\tEND";
 }

 /**
  * Format and output report results using the given information plus
  * OutputPage
  *
  * @param OutputPage $out OutputPage to print to
  * @param Skin $skin User skin to use [unused]
  * @param DatabaseBase $dbr (read) connection to use
  * @param int $res Result pointer
  * @param int $num Number of available result rows
  * @param int $offset Paging offset
  */
 protected function outputResults($out, $skin, $dbr, $res, $num, $offset)
 {
     if ($num > 0) {
         $gallery = new ImageGallery();
         # $res might contain the whole 1,000 rows, so we read up to
         # $num [should update this to use a Pager]
         for ($i = 0; $i < $num && ($row = $dbr->fetchObject($res)); $i++) {
             $namespace = isset($row->namespace) ? $row->namespace : NS_FILE;
             $title = Title::makeTitleSafe($namespace, $row->title);
             if ($title instanceof Title && $title->getNamespace() == NS_FILE) {
                 $gallery->add($title, $this->getCellHtml($row));
             }
         }
         $out->addHTML($gallery->toHtml());
     }
 }

 /**
  * @return DatabaseBase
  */
 function getMasterDB()
 {
     if (!isset($this->dbConn)) {
         $this->dbConn = DatabaseBase::factory($this->dbType, array('host' => $this->dbServer, 'user' => $this->dbUser, 'password' => $this->dbPassword, 'dbname' => $this->dbName, 'flags' => $this->dbFlags, 'tablePrefix' => $this->tablePrefix));
     }
     return $this->dbConn;
 }