includes/LinksUpdate.php

   1 <?php
   2 /**
   3  * See docs/deferred.txt
   4  *
   5  * @todo document (e.g. one-sentence top-level class description).
   6  */
   7 class LinksUpdate {
   8
   9         /**@{{
  10          * @private
  11          */
  12         var $mId,            //!< Page ID of the article linked from
  13                 $mTitle,         //!< Title object of the article linked from
  14                 $mLinks,         //!< Map of title strings to IDs for the links in the document
  15                 $mImages,        //!< DB keys of the images used, in the array key only
  16                 $mTemplates,     //!< Map of title strings to IDs for the template references, including broken ones
  17                 $mExternals,     //!< URLs of external links, array key only
  18                 $mCategories,    //!< Map of category names to sort keys
  19                 $mInterlangs,    //!< Map of language codes to titles
  20                 $mProperties,    //!< Map of arbitrary name to value
  21                 $mDb,            //!< Database connection reference
  22                 $mOptions,       //!< SELECT options to be used (array)
  23                 $mRecursive;     //!< Whether to queue jobs for recursive updates
  24         /**@}}*/
  25
  26         /**
  27          * Constructor
  28          *
  29          * @param Title $title Title of the page we're updating
  30          * @param ParserOutput $parserOutput Output from a full parse of this page
  31          * @param bool $recursive Queue jobs for recursive updates?
  32          */
  33         function LinksUpdate( $title, $parserOutput, $recursive = true ) {
  34                 global $wgAntiLockFlags;
  35
  36                 if ( $wgAntiLockFlags & ALF_NO_LINK_LOCK ) {
  37                         $this->mOptions = array();
  38                 } else {
  39                         $this->mOptions = array( 'FOR UPDATE' );
  40                 }
  41                 $this->mDb = wfGetDB( DB_MASTER );
  42
  43                 if ( !is_object( $title ) ) {
  44                         throw new MWException( "The calling convention to LinksUpdate::LinksUpdate() has changed. " .
  45                                 "Please see Article::editUpdates() for an invocation example.\n" );
  46                 }
  47                 $this->mTitle = $title;
  48                 $this->mId = $title->getArticleID();
  49
  50                 $this->mParserOutput = $parserOutput;
  51                 $this->mLinks = $parserOutput->getLinks();
  52                 $this->mImages = $parserOutput->getImages();
  53                 $this->mTemplates = $parserOutput->getTemplates();
  54                 $this->mExternals = $parserOutput->getExternalLinks();
  55                 $this->mCategories = $parserOutput->getCategories();
  56                 $this->mProperties = $parserOutput->getProperties();
  57
  58                 # Convert the format of the interlanguage links
  59                 # I didn't want to change it in the ParserOutput, because that array is passed all
  60                 # the way back to the skin, so either a skin API break would be required, or an
  61                 # inefficient back-conversion.
  62                 $ill = $parserOutput->getLanguageLinks();
  63                 $this->mInterlangs = array();
  64                 foreach ( $ill as $link ) {
  65                         list( $key, $title ) = explode( ':', $link, 2 );
  66                         $this->mInterlangs[$key] = $title;
  67                 }
  68
  69                 $this->mRecursive = $recursive;
  70                 $this->mTouchTmplLinks = false;
  71
  72                 wfRunHooks( 'LinksUpdateConstructed', array( &$this ) );
  73         }
  74
  75         /**
  76          * Update link tables with outgoing links from an updated article
  77          */
  78         public function doUpdate() {
  79                 global $wgUseDumbLinkUpdate;
  80
  81                 wfRunHooks( 'LinksUpdate', array( &$this ) );
  82                 if ( $wgUseDumbLinkUpdate ) {
  83                         $this->doDumbUpdate();
  84                 } else {
  85                         $this->doIncrementalUpdate();
  86                 }
  87                 wfRunHooks( 'LinksUpdateComplete', array( &$this ) );
  88         }
  89
  90         protected function doIncrementalUpdate() {
  91                 wfProfileIn( __METHOD__ );
  92
  93                 # Page links
  94                 $existing = $this->getExistingLinks();
  95                 $this->incrTableUpdate( 'pagelinks', 'pl', $this->getLinkDeletions( $existing ),
  96                         $this->getLinkInsertions( $existing ) );
  97
  98                 # Image links
  99                 $existing = $this->getExistingImages();
 100
 101                 $imageDeletes = $this->getImageDeletions( $existing );
 102                 $this->incrTableUpdate( 'imagelinks', 'il', $imageDeletes, $this->getImageInsertions( $existing ) );
 103
 104                 # Invalidate all image description pages which had links added or removed
 105                 $imageUpdates = $imageDeletes + array_diff_key( $this->mImages, $existing );
 106                 $this->invalidateImageDescriptions( $imageUpdates );
 107
 108                 # External links
 109                 $existing = $this->getExistingExternals();
 110                 $this->incrTableUpdate( 'externallinks', 'el', $this->getExternalDeletions( $existing ),
 111                 $this->getExternalInsertions( $existing ) );
 112
 113                 # Language links
 114                 $existing = $this->getExistingInterlangs();
 115                 $this->incrTableUpdate( 'langlinks', 'll', $this->getInterlangDeletions( $existing ),
 116                         $this->getInterlangInsertions( $existing ) );
 117
 118                 # Template links
 119                 $existing = $this->getExistingTemplates();
 120                 $this->incrTableUpdate( 'templatelinks', 'tl', $this->getTemplateDeletions( $existing ),
 121                         $this->getTemplateInsertions( $existing ) );
 122
 123                 # Category links
 124                 $existing = $this->getExistingCategories();
 125
 126                 $categoryDeletes = $this->getCategoryDeletions( $existing );
 127
 128                 $this->incrTableUpdate( 'categorylinks', 'cl', $categoryDeletes, $this->getCategoryInsertions( $existing ) );
 129
 130                 # Invalidate all categories which were added, deleted or changed (set symmetric difference)
 131                 $categoryInserts = array_diff_assoc( $this->mCategories, $existing );
 132                 $categoryUpdates = $categoryInserts + $categoryDeletes;
 133                 $this->invalidateCategories( $categoryUpdates );
 134                 $this->updateCategoryCounts( $categoryInserts, $categoryDeletes );
 135
 136                 # Page properties
 137                 $existing = $this->getExistingProperties();
 138
 139                 $propertiesDeletes = $this->getPropertyDeletions( $existing );
 140
 141                 $this->incrTableUpdate( 'page_props', 'pp', $propertiesDeletes, $this->getPropertyInsertions( $existing ) );
 142
 143                 # Invalidate the necessary pages
 144                 $changed = $propertiesDeletes + array_diff_assoc( $this->mProperties, $existing );
 145                 $this->invalidateProperties( $changed );
 146
 147                 # Refresh links of all pages including this page
 148                 # This will be in a separate transaction
 149                 if ( $this->mRecursive ) {
 150                         $this->queueRecursiveJobs();
 151                 }
 152
 153                 wfProfileOut( __METHOD__ );
 154         }
 155
 156         /**
 157          * Link update which clears the previous entries and inserts new ones
 158          * May be slower or faster depending on level of lock contention and write speed of DB
 159          * Also useful where link table corruption needs to be repaired, e.g. in refreshLinks.php
 160          */
 161         protected function doDumbUpdate() {
 162                 wfProfileIn( __METHOD__ );
 163
 164                 # Refresh category pages and image description pages
 165                 $existing = $this->getExistingCategories();
 166                 $categoryInserts = array_diff_assoc( $this->mCategories, $existing );
 167                 $categoryDeletes = array_diff_assoc( $existing, $this->mCategories );
 168                 $categoryUpdates = $categoryInserts + $categoryDeletes;
 169                 $existing = $this->getExistingImages();
 170                 $imageUpdates = array_diff_key( $existing, $this->mImages ) + array_diff_key( $this->mImages, $existing );
 171
 172                 $this->dumbTableUpdate( 'pagelinks',     $this->getLinkInsertions(),     'pl_from' );
 173                 $this->dumbTableUpdate( 'imagelinks',    $this->getImageInsertions(),    'il_from' );
 174                 $this->dumbTableUpdate( 'categorylinks', $this->getCategoryInsertions(), 'cl_from' );
 175                 $this->dumbTableUpdate( 'templatelinks', $this->getTemplateInsertions(), 'tl_from' );
 176                 $this->dumbTableUpdate( 'externallinks', $this->getExternalInsertions(), 'el_from' );
 177                 $this->dumbTableUpdate( 'langlinks',     $this->getInterlangInsertions(),'ll_from' );
 178                 $this->dumbTableUpdate( 'page_props',    $this->getPropertyInsertions(), 'pp_page' );
 179
 180                 # Update the cache of all the category pages and image description
 181                 # pages which were changed, and fix the category table count
 182                 $this->invalidateCategories( $categoryUpdates );
 183                 $this->updateCategoryCounts( $categoryInserts, $categoryDeletes );
 184                 $this->invalidateImageDescriptions( $imageUpdates );
 185
 186                 # Refresh links of all pages including this page
 187                 # This will be in a separate transaction
 188                 if ( $this->mRecursive ) {
 189                         $this->queueRecursiveJobs();
 190                 }
 191
 192                 wfProfileOut( __METHOD__ );
 193         }
 194
 195         function queueRecursiveJobs() {
 196                 global $wgUpdateRowsPerJob;
 197                 wfProfileIn( __METHOD__ );
 198
 199                 $cache = $this->mTitle->getBacklinkCache();
 200                 $batches = $cache->partition( 'templatelinks', $wgUpdateRowsPerJob );
 201                 $jobs = array();
 202                 foreach ( $batches as $batch ) {
 203                         list( $start, $end ) = $batch;
 204                         $params = array(
 205                                 'start' => $start,
 206                                 'end' => $end,
 207                         );
 208                         $jobs[] = new RefreshLinksJob2( $this->mTitle, $params );
 209                 }
 210                 Job::batchInsert( $jobs );
 211
 212                 wfProfileOut( __METHOD__ );
 213         }
 214
 215         /**
 216          * Invalidate the cache of a list of pages from a single namespace
 217          *
 218          * @param integer $namespace
 219          * @param array $dbkeys
 220          */
 221         function invalidatePages( $namespace, $dbkeys ) {
 222                 if ( !count( $dbkeys ) ) {
 223                         return;
 224                 }
 225
 226                 /**
 227                  * Determine which pages need to be updated
 228                  * This is necessary to prevent the job queue from smashing the DB with
 229                  * large numbers of concurrent invalidations of the same page
 230                  */
 231                 $now = $this->mDb->timestamp();
 232                 $ids = array();
 233                 $res = $this->mDb->select( 'page', array( 'page_id' ),
 234                         array(
 235                                 'page_namespace' => $namespace,
 236                                 'page_title IN (' . $this->mDb->makeList( $dbkeys ) . ')',
 237                                 'page_touched < ' . $this->mDb->addQuotes( $now )
 238                         ), __METHOD__
 239                 );
 240                 while ( $row = $this->mDb->fetchObject( $res ) ) {
 241                         $ids[] = $row->page_id;
 242                 }
 243                 if ( !count( $ids ) ) {
 244                         return;
 245                 }
 246
 247                 /**
 248                  * Do the update
 249                  * We still need the page_touched condition, in case the row has changed since
 250                  * the non-locking select above.
 251                  */
 252                 $this->mDb->update( 'page', array( 'page_touched' => $now ),
 253                         array(
 254                                 'page_id IN (' . $this->mDb->makeList( $ids ) . ')',
 255                                 'page_touched < ' . $this->mDb->addQuotes( $now )
 256                         ), __METHOD__
 257                 );
 258         }
 259
 260         function invalidateCategories( $cats ) {
 261                 $this->invalidatePages( NS_CATEGORY, array_keys( $cats ) );
 262         }
 263
 264         /**
 265          * Update all the appropriate counts in the category table.
 266          * @param $added associative array of category name => sort key
 267          * @param $deleted associative array of category name => sort key
 268          */
 269         function updateCategoryCounts( $added, $deleted ) {
 270                 $a = new Article($this->mTitle);
 271                 $a->updateCategoryCounts(
 272                         array_keys( $added ), array_keys( $deleted )
 273                 );
 274         }
 275
 276         function invalidateImageDescriptions( $images ) {
 277                 $this->invalidatePages( NS_FILE, array_keys( $images ) );
 278         }
 279
 280         function dumbTableUpdate( $table, $insertions, $fromField ) {
 281                 $this->mDb->delete( $table, array( $fromField => $this->mId ), __METHOD__ );
 282                 if ( count( $insertions ) ) {
 283                         # The link array was constructed without FOR UPDATE, so there may
 284                         # be collisions.  This may cause minor link table inconsistencies,
 285                         # which is better than crippling the site with lock contention.
 286                         $this->mDb->insert( $table, $insertions, __METHOD__, array( 'IGNORE' ) );
 287                 }
 288         }
 289
 290         /**
 291          * Make a WHERE clause from a 2-d NS/dbkey array
 292          *
 293          * @param array $arr 2-d array indexed by namespace and DB key
 294          * @param string $prefix Field name prefix, without the underscore
 295          */
 296         function makeWhereFrom2d( &$arr, $prefix ) {
 297                 $lb = new LinkBatch;
 298                 $lb->setArray( $arr );
 299                 return $lb->constructSet( $prefix, $this->mDb );
 300         }
 301
 302         /**
 303          * Update a table by doing a delete query then an insert query
 304          * @private
 305          */
 306         function incrTableUpdate( $table, $prefix, $deletions, $insertions ) {
 307                 if ( $table == 'page_props' ) {
 308                         $fromField = 'pp_page';
 309                 } else {
 310                         $fromField = "{$prefix}_from";
 311                 }
 312                 $where = array( $fromField => $this->mId );
 313                 if ( $table == 'pagelinks' || $table == 'templatelinks' ) {
 314                         $clause = $this->makeWhereFrom2d( $deletions, $prefix );
 315                         if ( $clause ) {
 316                                 $where[] = $clause;
 317                         } else {
 318                                 $where = false;
 319                         }
 320                 } else {
 321                         if ( $table == 'langlinks' ) {
 322                                 $toField = 'll_lang';
 323                         } elseif ( $table == 'page_props' ) {
 324                                 $toField = 'pp_propname';
 325                         } else {
 326                                 $toField = $prefix . '_to';
 327                         }
 328                         if ( count( $deletions ) ) {
 329                                 $where[] = "$toField IN (" . $this->mDb->makeList( array_keys( $deletions ) ) . ')';
 330                         } else {
 331                                 $where = false;
 332                         }
 333                 }
 334                 if ( $where ) {
 335                         $this->mDb->delete( $table, $where, __METHOD__ );
 336                 }
 337                 if ( count( $insertions ) ) {
 338                         $this->mDb->insert( $table, $insertions, __METHOD__, 'IGNORE' );
 339                 }
 340         }
 341
 342
 343         /**
 344          * Get an array of pagelinks insertions for passing to the DB
 345          * Skips the titles specified by the 2-D array $existing
 346          * @private
 347          */
 348         function getLinkInsertions( $existing = array() ) {
 349                 $arr = array();
 350                 foreach( $this->mLinks as $ns => $dbkeys ) {
 351                         # array_diff_key() was introduced in PHP 5.1, there is a compatibility function
 352                         # in GlobalFunctions.php
 353                         $diffs = isset( $existing[$ns] ) ? array_diff_key( $dbkeys, $existing[$ns] ) : $dbkeys;
 354                         foreach ( $diffs as $dbk => $id ) {
 355                                 $arr[] = array(
 356                                         'pl_from'      => $this->mId,
 357                                         'pl_namespace' => $ns,
 358                                         'pl_title'     => $dbk
 359                                 );
 360                         }
 361                 }
 362                 return $arr;
 363         }
 364
 365         /**
 366          * Get an array of template insertions. Like getLinkInsertions()
 367          * @private
 368          */
 369         function getTemplateInsertions( $existing = array() ) {
 370                 $arr = array();
 371                 foreach( $this->mTemplates as $ns => $dbkeys ) {
 372                         $diffs = isset( $existing[$ns] ) ? array_diff_key( $dbkeys, $existing[$ns] ) : $dbkeys;
 373                         foreach ( $diffs as $dbk => $id ) {
 374                                 $arr[] = array(
 375                                         'tl_from'      => $this->mId,
 376                                         'tl_namespace' => $ns,
 377                                         'tl_title'     => $dbk
 378                                 );
 379                         }
 380                 }
 381                 return $arr;
 382         }
 383
 384         /**
 385          * Get an array of image insertions
 386          * Skips the names specified in $existing
 387          * @private
 388          */
 389         function getImageInsertions( $existing = array() ) {
 390                 $arr = array();
 391                 $diffs = array_diff_key( $this->mImages, $existing );
 392                 foreach( $diffs as $iname => $dummy ) {
 393                         $arr[] = array(
 394                                 'il_from' => $this->mId,
 395                                 'il_to'   => $iname
 396                         );
 397                 }
 398                 return $arr;
 399         }
 400
 401         /**
 402          * Get an array of externallinks insertions. Skips the names specified in $existing
 403          * @private
 404          */
 405         function getExternalInsertions( $existing = array() ) {
 406                 $arr = array();
 407                 $diffs = array_diff_key( $this->mExternals, $existing );
 408                 foreach( $diffs as $url => $dummy ) {
 409                         $arr[] = array(
 410                                 'el_from'   => $this->mId,
 411                                 'el_to'     => $url,
 412                                 'el_index'  => wfMakeUrlIndex( $url ),
 413                         );
 414                 }
 415                 return $arr;
 416         }
 417
 418         /**
 419          * Get an array of category insertions
 420          * @param array $existing Array mapping existing category names to sort keys. If both
 421          * match a link in $this, the link will be omitted from the output
 422          * @private
 423          */
 424         function getCategoryInsertions( $existing = array() ) {
 425                 global $wgContLang;
 426                 $diffs = array_diff_assoc( $this->mCategories, $existing );
 427                 $arr = array();
 428                 foreach ( $diffs as $name => $sortkey ) {
 429                         $nt = Title::makeTitleSafe( NS_CATEGORY, $name );
 430                         $wgContLang->findVariantLink( $name, $nt, true );
 431                         // for category redirection
 432                         if ( $nt->isRedirect() ) {
 433                                 $at = new Article( $nt );
 434                                 $nt = $at->getRedirectTarget();
 435                                 // we only redirect a category to another category
 436                                 if ( $nt->getNamespace() == NS_CATEGORY )
 437                                         $name = $nt->getText();
 438                         }
 439                         $arr[] = array(
 440                                 'cl_from'    => $this->mId,
 441                                 'cl_to'      => $name,
 442                                 'cl_sortkey' => $sortkey,
 443                                 'cl_timestamp' => $this->mDb->timestamp()
 444                         );
 445                 }
 446                 return $arr;
 447         }
 448
 449         /**
 450          * Get an array of interlanguage link insertions
 451          * @param array $existing Array mapping existing language codes to titles
 452          * @private
 453          */
 454         function getInterlangInsertions( $existing = array() ) {
 455             $diffs = array_diff_assoc( $this->mInterlangs, $existing );
 456             $arr = array();
 457             foreach( $diffs as $lang => $title ) {
 458                 $arr[] = array(
 459                     'll_from'  => $this->mId,
 460                     'll_lang'  => $lang,
 461                     'll_title' => $title
 462                 );
 463             }
 464             return $arr;
 465         }
 466
 467         /**
 468          * Get an array of page property insertions
 469          */
 470         function getPropertyInsertions( $existing = array() ) {
 471                 $diffs = array_diff_assoc( $this->mProperties, $existing );
 472                 $arr = array();
 473                 foreach ( $diffs as $name => $value ) {
 474                         $arr[] = array(
 475                                 'pp_page'      => $this->mId,
 476                                 'pp_propname'  => $name,
 477                                 'pp_value'     => $value,
 478                         );
 479                 }
 480                 return $arr;
 481         }
 482
 483
 484         /**
 485          * Given an array of existing links, returns those links which are not in $this
 486          * and thus should be deleted.
 487          * @private
 488          */
 489         function getLinkDeletions( $existing ) {
 490                 $del = array();
 491                 foreach ( $existing as $ns => $dbkeys ) {
 492                         if ( isset( $this->mLinks[$ns] ) ) {
 493                                 $del[$ns] = array_diff_key( $existing[$ns], $this->mLinks[$ns] );
 494                         } else {
 495                                 $del[$ns] = $existing[$ns];
 496                         }
 497                 }
 498                 return $del;
 499         }
 500
 501         /**
 502          * Given an array of existing templates, returns those templates which are not in $this
 503          * and thus should be deleted.
 504          * @private
 505          */
 506         function getTemplateDeletions( $existing ) {
 507                 $del = array();
 508                 foreach ( $existing as $ns => $dbkeys ) {
 509                         if ( isset( $this->mTemplates[$ns] ) ) {
 510                                 $del[$ns] = array_diff_key( $existing[$ns], $this->mTemplates[$ns] );
 511                         } else {
 512                                 $del[$ns] = $existing[$ns];
 513                         }
 514                 }
 515                 return $del;
 516         }
 517
 518         /**
 519          * Given an array of existing images, returns those images which are not in $this
 520          * and thus should be deleted.
 521          * @private
 522          */
 523         function getImageDeletions( $existing ) {
 524                 return array_diff_key( $existing, $this->mImages );
 525         }
 526
 527         /**
 528          * Given an array of existing external links, returns those links which are not
 529          * in $this and thus should be deleted.
 530          * @private
 531          */
 532         function getExternalDeletions( $existing ) {
 533                 return array_diff_key( $existing, $this->mExternals );
 534         }
 535
 536         /**
 537          * Given an array of existing categories, returns those categories which are not in $this
 538          * and thus should be deleted.
 539          * @private
 540          */
 541         function getCategoryDeletions( $existing ) {
 542                 return array_diff_assoc( $existing, $this->mCategories );
 543         }
 544
 545         /**
 546          * Given an array of existing interlanguage links, returns those links which are not
 547          * in $this and thus should be deleted.
 548          * @private
 549          */
 550         function getInterlangDeletions( $existing ) {
 551             return array_diff_assoc( $existing, $this->mInterlangs );
 552         }
 553
 554         /**
 555          * Get array of properties which should be deleted.
 556          * @private
 557          */
 558         function getPropertyDeletions( $existing ) {
 559                 return array_diff_assoc( $existing, $this->mProperties );
 560         }
 561
 562         /**
 563          * Get an array of existing links, as a 2-D array
 564          * @private
 565          */
 566         function getExistingLinks() {
 567                 $res = $this->mDb->select( 'pagelinks', array( 'pl_namespace', 'pl_title' ),
 568                         array( 'pl_from' => $this->mId ), __METHOD__, $this->mOptions );
 569                 $arr = array();
 570                 while ( $row = $this->mDb->fetchObject( $res ) ) {
 571                         if ( !isset( $arr[$row->pl_namespace] ) ) {
 572                                 $arr[$row->pl_namespace] = array();
 573                         }
 574                         $arr[$row->pl_namespace][$row->pl_title] = 1;
 575                 }
 576                 $this->mDb->freeResult( $res );
 577                 return $arr;
 578         }
 579
 580         /**
 581          * Get an array of existing templates, as a 2-D array
 582          * @private
 583          */
 584         function getExistingTemplates() {
 585                 $res = $this->mDb->select( 'templatelinks', array( 'tl_namespace', 'tl_title' ),
 586                         array( 'tl_from' => $this->mId ), __METHOD__, $this->mOptions );
 587                 $arr = array();
 588                 while ( $row = $this->mDb->fetchObject( $res ) ) {
 589                         if ( !isset( $arr[$row->tl_namespace] ) ) {
 590                                 $arr[$row->tl_namespace] = array();
 591                         }
 592                         $arr[$row->tl_namespace][$row->tl_title] = 1;
 593                 }
 594                 $this->mDb->freeResult( $res );
 595                 return $arr;
 596         }
 597
 598         /**
 599          * Get an array of existing images, image names in the keys
 600          * @private
 601          */
 602         function getExistingImages() {
 603                 $res = $this->mDb->select( 'imagelinks', array( 'il_to' ),
 604                         array( 'il_from' => $this->mId ), __METHOD__, $this->mOptions );
 605                 $arr = array();
 606                 while ( $row = $this->mDb->fetchObject( $res ) ) {
 607                         $arr[$row->il_to] = 1;
 608                 }
 609                 $this->mDb->freeResult( $res );
 610                 return $arr;
 611         }
 612
 613         /**
 614          * Get an array of existing external links, URLs in the keys
 615          * @private
 616          */
 617         function getExistingExternals() {
 618                 $res = $this->mDb->select( 'externallinks', array( 'el_to' ),
 619                         array( 'el_from' => $this->mId ), __METHOD__, $this->mOptions );
 620                 $arr = array();
 621                 while ( $row = $this->mDb->fetchObject( $res ) ) {
 622                         $arr[$row->el_to] = 1;
 623                 }
 624                 $this->mDb->freeResult( $res );
 625                 return $arr;
 626         }
 627
 628         /**
 629          * Get an array of existing categories, with the name in the key and sort key in the value.
 630          * @private
 631          */
 632         function getExistingCategories() {
 633                 $res = $this->mDb->select( 'categorylinks', array( 'cl_to', 'cl_sortkey' ),
 634                         array( 'cl_from' => $this->mId ), __METHOD__, $this->mOptions );
 635                 $arr = array();
 636                 while ( $row = $this->mDb->fetchObject( $res ) ) {
 637                         $arr[$row->cl_to] = $row->cl_sortkey;
 638                 }
 639                 $this->mDb->freeResult( $res );
 640                 return $arr;
 641         }
 642
 643         /**
 644          * Get an array of existing interlanguage links, with the language code in the key and the
 645          * title in the value.
 646          * @private
 647          */
 648         function getExistingInterlangs() {
 649                 $res = $this->mDb->select( 'langlinks', array( 'll_lang', 'll_title' ),
 650                         array( 'll_from' => $this->mId ), __METHOD__, $this->mOptions );
 651                 $arr = array();
 652                 while ( $row = $this->mDb->fetchObject( $res ) ) {
 653                         $arr[$row->ll_lang] = $row->ll_title;
 654                 }
 655                 return $arr;
 656         }
 657
 658         /**
 659          * Get an array of existing categories, with the name in the key and sort key in the value.
 660          * @private
 661          */
 662         function getExistingProperties() {
 663                 $res = $this->mDb->select( 'page_props', array( 'pp_propname', 'pp_value' ),
 664                         array( 'pp_page' => $this->mId ), __METHOD__, $this->mOptions );
 665                 $arr = array();
 666                 while ( $row = $this->mDb->fetchObject( $res ) ) {
 667                         $arr[$row->pp_propname] = $row->pp_value;
 668                 }
 669                 $this->mDb->freeResult( $res );
 670                 return $arr;
 671         }
 672
 673
 674         /**
 675          * Return the title object of the page being updated
 676          */
 677         function getTitle() {
 678                 return $this->mTitle;
 679         }
 680
 681         /**
 682          * Invalidate any necessary link lists related to page property changes
 683          */
 684         function invalidateProperties( $changed ) {
 685                 global $wgPagePropLinkInvalidations;
 686
 687                 foreach ( $changed as $name => $value ) {
 688                         if ( isset( $wgPagePropLinkInvalidations[$name] ) ) {
 689                                 $inv = $wgPagePropLinkInvalidations[$name];
 690                                 if ( !is_array( $inv ) ) {
 691                                         $inv = array( $inv );
 692                                 }
 693                                 foreach ( $inv as $table ) {
 694                                         $update = new HTMLCacheUpdate( $this->mTitle, $table );
 695                                         $update->doUpdate();
 696                                 }
 697                         }
 698                 }
 699         }
 700 }