includes/watcheditem/WatchedItemStore.php

   1 <?php
   2
   3 use Wikimedia\Rdbms\IDatabase;
   4 use Liuggio\StatsdClient\Factory\StatsdDataFactoryInterface;
   5 use MediaWiki\Linker\LinkTarget;
   6 use Wikimedia\Assert\Assert;
   7 use Wikimedia\ScopedCallback;
   8 use Wikimedia\Rdbms\ILBFactory;
   9 use Wikimedia\Rdbms\LoadBalancer;
  10
  11 /**
  12  * Storage layer class for WatchedItems.
  13  * Database interaction & caching
  14  * TODO caching should be factored out into a CachingWatchedItemStore class
  15  *
  16  * @author Addshore
  17  * @since 1.27
  18  */
  19 class WatchedItemStore implements WatchedItemStoreInterface, StatsdAwareInterface {
  20
  21         /**
  22          * @var ILBFactory
  23          */
  24         private $lbFactory;
  25
  26         /**
  27          * @var LoadBalancer
  28          */
  29         private $loadBalancer;
  30
  31         /**
  32          * @var ReadOnlyMode
  33          */
  34         private $readOnlyMode;
  35
  36         /**
  37          * @var HashBagOStuff
  38          */
  39         private $cache;
  40
  41         /**
  42          * @var array[] Looks like $cacheIndex[Namespace ID][Target DB Key][User Id] => 'key'
  43          * The index is needed so that on mass changes all relevant items can be un-cached.
  44          * For example: Clearing a users watchlist of all items or updating notification timestamps
  45          *              for all users watching a single target.
  46          */
  47         private $cacheIndex = [];
  48
  49         /**
  50          * @var callable|null
  51          */
  52         private $deferredUpdatesAddCallableUpdateCallback;
  53
  54         /**
  55          * @var callable|null
  56          */
  57         private $revisionGetTimestampFromIdCallback;
  58
  59         /**
  60          * @var int
  61          */
  62         private $updateRowsPerQuery;
  63
  64         /**
  65          * @var StatsdDataFactoryInterface
  66          */
  67         private $stats;
  68
  69         /**
  70          * @param ILBFactory $lbFactory
  71          * @param HashBagOStuff $cache
  72          * @param ReadOnlyMode $readOnlyMode
  73          * @param int $updateRowsPerQuery
  74          */
  75         public function __construct(
  76                 ILBFactory $lbFactory,
  77                 HashBagOStuff $cache,
  78                 ReadOnlyMode $readOnlyMode,
  79                 $updateRowsPerQuery
  80         ) {
  81                 $this->lbFactory = $lbFactory;
  82                 $this->loadBalancer = $lbFactory->getMainLB();
  83                 $this->cache = $cache;
  84                 $this->readOnlyMode = $readOnlyMode;
  85                 $this->stats = new NullStatsdDataFactory();
  86                 $this->deferredUpdatesAddCallableUpdateCallback =
  87                         [ DeferredUpdates::class, 'addCallableUpdate' ];
  88                 $this->revisionGetTimestampFromIdCallback =
  89                         [ Revision::class, 'getTimestampFromId' ];
  90                 $this->updateRowsPerQuery = $updateRowsPerQuery;
  91         }
  92
  93         /**
  94          * @param StatsdDataFactoryInterface $stats
  95          */
  96         public function setStatsdDataFactory( StatsdDataFactoryInterface $stats ) {
  97                 $this->stats = $stats;
  98         }
  99
 100         /**
 101          * Overrides the DeferredUpdates::addCallableUpdate callback
 102          * This is intended for use while testing and will fail if MW_PHPUNIT_TEST is not defined.
 103          *
 104          * @param callable $callback
 105          *
 106          * @see DeferredUpdates::addCallableUpdate for callback signiture
 107          *
 108          * @return ScopedCallback to reset the overridden value
 109          * @throws MWException
 110          */
 111         public function overrideDeferredUpdatesAddCallableUpdateCallback( callable $callback ) {
 112                 if ( !defined( 'MW_PHPUNIT_TEST' ) ) {
 113                         throw new MWException(
 114                                 'Cannot override DeferredUpdates::addCallableUpdate callback in operation.'
 115                         );
 116                 }
 117                 $previousValue = $this->deferredUpdatesAddCallableUpdateCallback;
 118                 $this->deferredUpdatesAddCallableUpdateCallback = $callback;
 119                 return new ScopedCallback( function () use ( $previousValue ) {
 120                         $this->deferredUpdatesAddCallableUpdateCallback = $previousValue;
 121                 } );
 122         }
 123
 124         /**
 125          * Overrides the Revision::getTimestampFromId callback
 126          * This is intended for use while testing and will fail if MW_PHPUNIT_TEST is not defined.
 127          *
 128          * @param callable $callback
 129          * @see Revision::getTimestampFromId for callback signiture
 130          *
 131          * @return ScopedCallback to reset the overridden value
 132          * @throws MWException
 133          */
 134         public function overrideRevisionGetTimestampFromIdCallback( callable $callback ) {
 135                 if ( !defined( 'MW_PHPUNIT_TEST' ) ) {
 136                         throw new MWException(
 137                                 'Cannot override Revision::getTimestampFromId callback in operation.'
 138                         );
 139                 }
 140                 $previousValue = $this->revisionGetTimestampFromIdCallback;
 141                 $this->revisionGetTimestampFromIdCallback = $callback;
 142                 return new ScopedCallback( function () use ( $previousValue ) {
 143                         $this->revisionGetTimestampFromIdCallback = $previousValue;
 144                 } );
 145         }
 146
 147         private function getCacheKey( User $user, LinkTarget $target ) {
 148                 return $this->cache->makeKey(
 149                         (string)$target->getNamespace(),
 150                         $target->getDBkey(),
 151                         (string)$user->getId()
 152                 );
 153         }
 154
 155         private function cache( WatchedItem $item ) {
 156                 $user = $item->getUser();
 157                 $target = $item->getLinkTarget();
 158                 $key = $this->getCacheKey( $user, $target );
 159                 $this->cache->set( $key, $item );
 160                 $this->cacheIndex[$target->getNamespace()][$target->getDBkey()][$user->getId()] = $key;
 161                 $this->stats->increment( 'WatchedItemStore.cache' );
 162         }
 163
 164         private function uncache( User $user, LinkTarget $target ) {
 165                 $this->cache->delete( $this->getCacheKey( $user, $target ) );
 166                 unset( $this->cacheIndex[$target->getNamespace()][$target->getDBkey()][$user->getId()] );
 167                 $this->stats->increment( 'WatchedItemStore.uncache' );
 168         }
 169
 170         private function uncacheLinkTarget( LinkTarget $target ) {
 171                 $this->stats->increment( 'WatchedItemStore.uncacheLinkTarget' );
 172                 if ( !isset( $this->cacheIndex[$target->getNamespace()][$target->getDBkey()] ) ) {
 173                         return;
 174                 }
 175                 foreach ( $this->cacheIndex[$target->getNamespace()][$target->getDBkey()] as $key ) {
 176                         $this->stats->increment( 'WatchedItemStore.uncacheLinkTarget.items' );
 177                         $this->cache->delete( $key );
 178                 }
 179         }
 180
 181         private function uncacheUser( User $user ) {
 182                 $this->stats->increment( 'WatchedItemStore.uncacheUser' );
 183                 foreach ( $this->cacheIndex as $ns => $dbKeyArray ) {
 184                         foreach ( $dbKeyArray as $dbKey => $userArray ) {
 185                                 if ( isset( $userArray[$user->getId()] ) ) {
 186                                         $this->stats->increment( 'WatchedItemStore.uncacheUser.items' );
 187                                         $this->cache->delete( $userArray[$user->getId()] );
 188                                 }
 189                         }
 190                 }
 191         }
 192
 193         /**
 194          * @param User $user
 195          * @param LinkTarget $target
 196          *
 197          * @return WatchedItem|false
 198          */
 199         private function getCached( User $user, LinkTarget $target ) {
 200                 return $this->cache->get( $this->getCacheKey( $user, $target ) );
 201         }
 202
 203         /**
 204          * Return an array of conditions to select or update the appropriate database
 205          * row.
 206          *
 207          * @param User $user
 208          * @param LinkTarget $target
 209          *
 210          * @return array
 211          */
 212         private function dbCond( User $user, LinkTarget $target ) {
 213                 return [
 214                         'wl_user' => $user->getId(),
 215                         'wl_namespace' => $target->getNamespace(),
 216                         'wl_title' => $target->getDBkey(),
 217                 ];
 218         }
 219
 220         /**
 221          * @param int $dbIndex DB_MASTER or DB_REPLICA
 222          *
 223          * @return IDatabase
 224          * @throws MWException
 225          */
 226         private function getConnectionRef( $dbIndex ) {
 227                 return $this->loadBalancer->getConnectionRef( $dbIndex, [ 'watchlist' ] );
 228         }
 229
 230         /**
 231          * Deletes ALL watched items for the given user when under
 232          * $updateRowsPerQuery entries exist.
 233          *
 234          * @since 1.30
 235          *
 236          * @param User $user
 237          *
 238          * @return bool true on success, false when too many items are watched
 239          */
 240         public function clearUserWatchedItems( User $user ) {
 241                 if ( $this->countWatchedItems( $user ) > $this->updateRowsPerQuery ) {
 242                         return false;
 243                 }
 244
 245                 $dbw = $this->loadBalancer->getConnectionRef( DB_MASTER );
 246                 $dbw->delete(
 247                         'watchlist',
 248                         [ 'wl_user' => $user->getId() ],
 249                         __METHOD__
 250                 );
 251                 $this->uncacheAllItemsForUser( $user );
 252
 253                 return true;
 254         }
 255
 256         private function uncacheAllItemsForUser( User $user ) {
 257                 $userId = $user->getId();
 258                 foreach ( $this->cacheIndex as $ns => $dbKeyIndex ) {
 259                         foreach ( $dbKeyIndex as $dbKey => $userIndex ) {
 260                                 if ( array_key_exists( $userId, $userIndex ) ) {
 261                                         $this->cache->delete( $userIndex[$userId] );
 262                                         unset( $this->cacheIndex[$ns][$dbKey][$userId] );
 263                                 }
 264                         }
 265                 }
 266
 267                 // Cleanup empty cache keys
 268                 foreach ( $this->cacheIndex as $ns => $dbKeyIndex ) {
 269                         foreach ( $dbKeyIndex as $dbKey => $userIndex ) {
 270                                 if ( empty( $this->cacheIndex[$ns][$dbKey] ) ) {
 271                                         unset( $this->cacheIndex[$ns][$dbKey] );
 272                                 }
 273                         }
 274                         if ( empty( $this->cacheIndex[$ns] ) ) {
 275                                 unset( $this->cacheIndex[$ns] );
 276                         }
 277                 }
 278         }
 279
 280         /**
 281          * Queues a job that will clear the users watchlist using the Job Queue.
 282          *
 283          * @since 1.31
 284          *
 285          * @param User $user
 286          */
 287         public function clearUserWatchedItemsUsingJobQueue( User $user ) {
 288                 $job = ClearUserWatchlistJob::newForUser( $user, $this->getMaxId() );
 289                 // TODO inject me.
 290                 JobQueueGroup::singleton()->push( $job );
 291         }
 292
 293         /**
 294          * @since 1.31
 295          * @return int The maximum current wl_id
 296          */
 297         public function getMaxId() {
 298                 $dbr = $this->getConnectionRef( DB_REPLICA );
 299                 return (int)$dbr->selectField(
 300                         'watchlist',
 301                         'MAX(wl_id)',
 302                         '',
 303                         __METHOD__
 304                 );
 305         }
 306
 307         /**
 308          * @since 1.31
 309          * @param User $user
 310          * @return int
 311          */
 312         public function countWatchedItems( User $user ) {
 313                 $dbr = $this->getConnectionRef( DB_REPLICA );
 314                 $return = (int)$dbr->selectField(
 315                         'watchlist',
 316                         'COUNT(*)',
 317                         [
 318                                 'wl_user' => $user->getId()
 319                         ],
 320                         __METHOD__
 321                 );
 322
 323                 return $return;
 324         }
 325
 326         /**
 327          * @since 1.27
 328          * @param LinkTarget $target
 329          * @return int
 330          */
 331         public function countWatchers( LinkTarget $target ) {
 332                 $dbr = $this->getConnectionRef( DB_REPLICA );
 333                 $return = (int)$dbr->selectField(
 334                         'watchlist',
 335                         'COUNT(*)',
 336                         [
 337                                 'wl_namespace' => $target->getNamespace(),
 338                                 'wl_title' => $target->getDBkey(),
 339                         ],
 340                         __METHOD__
 341                 );
 342
 343                 return $return;
 344         }
 345
 346         /**
 347          * @since 1.27
 348          * @param LinkTarget $target
 349          * @param string|int $threshold
 350          * @return int
 351          */
 352         public function countVisitingWatchers( LinkTarget $target, $threshold ) {
 353                 $dbr = $this->getConnectionRef( DB_REPLICA );
 354                 $visitingWatchers = (int)$dbr->selectField(
 355                         'watchlist',
 356                         'COUNT(*)',
 357                         [
 358                                 'wl_namespace' => $target->getNamespace(),
 359                                 'wl_title' => $target->getDBkey(),
 360                                 'wl_notificationtimestamp >= ' .
 361                                 $dbr->addQuotes( $dbr->timestamp( $threshold ) ) .
 362                                 ' OR wl_notificationtimestamp IS NULL'
 363                         ],
 364                         __METHOD__
 365                 );
 366
 367                 return $visitingWatchers;
 368         }
 369
 370         /**
 371          * @since 1.27
 372          * @param LinkTarget[] $targets
 373          * @param array $options
 374          * @return array
 375          */
 376         public function countWatchersMultiple( array $targets, array $options = [] ) {
 377                 $dbOptions = [ 'GROUP BY' => [ 'wl_namespace', 'wl_title' ] ];
 378
 379                 $dbr = $this->getConnectionRef( DB_REPLICA );
 380
 381                 if ( array_key_exists( 'minimumWatchers', $options ) ) {
 382                         $dbOptions['HAVING'] = 'COUNT(*) >= ' . (int)$options['minimumWatchers'];
 383                 }
 384
 385                 $lb = new LinkBatch( $targets );
 386                 $res = $dbr->select(
 387                         'watchlist',
 388                         [ 'wl_title', 'wl_namespace', 'watchers' => 'COUNT(*)' ],
 389                         [ $lb->constructSet( 'wl', $dbr ) ],
 390                         __METHOD__,
 391                         $dbOptions
 392                 );
 393
 394                 $watchCounts = [];
 395                 foreach ( $targets as $linkTarget ) {
 396                         $watchCounts[$linkTarget->getNamespace()][$linkTarget->getDBkey()] = 0;
 397                 }
 398
 399                 foreach ( $res as $row ) {
 400                         $watchCounts[$row->wl_namespace][$row->wl_title] = (int)$row->watchers;
 401                 }
 402
 403                 return $watchCounts;
 404         }
 405
 406         /**
 407          * @since 1.27
 408          * @param array $targetsWithVisitThresholds
 409          * @param int|null $minimumWatchers
 410          * @return array
 411          */
 412         public function countVisitingWatchersMultiple(
 413                 array $targetsWithVisitThresholds,
 414                 $minimumWatchers = null
 415         ) {
 416                 if ( $targetsWithVisitThresholds === [] ) {
 417                         // No titles requested => no results returned
 418                         return [];
 419                 }
 420
 421                 $dbr = $this->getConnectionRef( DB_REPLICA );
 422
 423                 $conds = $this->getVisitingWatchersCondition( $dbr, $targetsWithVisitThresholds );
 424
 425                 $dbOptions = [ 'GROUP BY' => [ 'wl_namespace', 'wl_title' ] ];
 426                 if ( $minimumWatchers !== null ) {
 427                         $dbOptions['HAVING'] = 'COUNT(*) >= ' . (int)$minimumWatchers;
 428                 }
 429                 $res = $dbr->select(
 430                         'watchlist',
 431                         [ 'wl_namespace', 'wl_title', 'watchers' => 'COUNT(*)' ],
 432                         $conds,
 433                         __METHOD__,
 434                         $dbOptions
 435                 );
 436
 437                 $watcherCounts = [];
 438                 foreach ( $targetsWithVisitThresholds as list( $target ) ) {
 439                         /* @var LinkTarget $target */
 440                         $watcherCounts[$target->getNamespace()][$target->getDBkey()] = 0;
 441                 }
 442
 443                 foreach ( $res as $row ) {
 444                         $watcherCounts[$row->wl_namespace][$row->wl_title] = (int)$row->watchers;
 445                 }
 446
 447                 return $watcherCounts;
 448         }
 449
 450         /**
 451          * Generates condition for the query used in a batch count visiting watchers.
 452          *
 453          * @param IDatabase $db
 454          * @param array $targetsWithVisitThresholds array of pairs (LinkTarget, last visit threshold)
 455          * @return string
 456          */
 457         private function getVisitingWatchersCondition(
 458                 IDatabase $db,
 459                 array $targetsWithVisitThresholds
 460         ) {
 461                 $missingTargets = [];
 462                 $namespaceConds = [];
 463                 foreach ( $targetsWithVisitThresholds as list( $target, $threshold ) ) {
 464                         if ( $threshold === null ) {
 465                                 $missingTargets[] = $target;
 466                                 continue;
 467                         }
 468                         /* @var LinkTarget $target */
 469                         $namespaceConds[$target->getNamespace()][] = $db->makeList( [
 470                                 'wl_title = ' . $db->addQuotes( $target->getDBkey() ),
 471                                 $db->makeList( [
 472                                         'wl_notificationtimestamp >= ' . $db->addQuotes( $db->timestamp( $threshold ) ),
 473                                         'wl_notificationtimestamp IS NULL'
 474                                 ], LIST_OR )
 475                         ], LIST_AND );
 476                 }
 477
 478                 $conds = [];
 479                 foreach ( $namespaceConds as $namespace => $pageConds ) {
 480                         $conds[] = $db->makeList( [
 481                                 'wl_namespace = ' . $namespace,
 482                                 '(' . $db->makeList( $pageConds, LIST_OR ) . ')'
 483                         ], LIST_AND );
 484                 }
 485
 486                 if ( $missingTargets ) {
 487                         $lb = new LinkBatch( $missingTargets );
 488                         $conds[] = $lb->constructSet( 'wl', $db );
 489                 }
 490
 491                 return $db->makeList( $conds, LIST_OR );
 492         }
 493
 494         /**
 495          * @since 1.27
 496          * @param User $user
 497          * @param LinkTarget $target
 498          * @return bool
 499          */
 500         public function getWatchedItem( User $user, LinkTarget $target ) {
 501                 if ( $user->isAnon() ) {
 502                         return false;
 503                 }
 504
 505                 $cached = $this->getCached( $user, $target );
 506                 if ( $cached ) {
 507                         $this->stats->increment( 'WatchedItemStore.getWatchedItem.cached' );
 508                         return $cached;
 509                 }
 510                 $this->stats->increment( 'WatchedItemStore.getWatchedItem.load' );
 511                 return $this->loadWatchedItem( $user, $target );
 512         }
 513
 514         /**
 515          * @since 1.27
 516          * @param User $user
 517          * @param LinkTarget $target
 518          * @return WatchedItem|bool
 519          */
 520         public function loadWatchedItem( User $user, LinkTarget $target ) {
 521                 // Only loggedin user can have a watchlist
 522                 if ( $user->isAnon() ) {
 523                         return false;
 524                 }
 525
 526                 $dbr = $this->getConnectionRef( DB_REPLICA );
 527                 $row = $dbr->selectRow(
 528                         'watchlist',
 529                         'wl_notificationtimestamp',
 530                         $this->dbCond( $user, $target ),
 531                         __METHOD__
 532                 );
 533
 534                 if ( !$row ) {
 535                         return false;
 536                 }
 537
 538                 $item = new WatchedItem(
 539                         $user,
 540                         $target,
 541                         wfTimestampOrNull( TS_MW, $row->wl_notificationtimestamp )
 542                 );
 543                 $this->cache( $item );
 544
 545                 return $item;
 546         }
 547
 548         /**
 549          * @since 1.27
 550          * @param User $user
 551          * @param array $options
 552          * @return WatchedItem[]
 553          */
 554         public function getWatchedItemsForUser( User $user, array $options = [] ) {
 555                 $options += [ 'forWrite' => false ];
 556
 557                 $dbOptions = [];
 558                 if ( array_key_exists( 'sort', $options ) ) {
 559                         Assert::parameter(
 560                                 ( in_array( $options['sort'], [ self::SORT_ASC, self::SORT_DESC ] ) ),
 561                                 '$options[\'sort\']',
 562                                 'must be SORT_ASC or SORT_DESC'
 563                         );
 564                         $dbOptions['ORDER BY'] = [
 565                                 "wl_namespace {$options['sort']}",
 566                                 "wl_title {$options['sort']}"
 567                         ];
 568                 }
 569                 $db = $this->getConnectionRef( $options['forWrite'] ? DB_MASTER : DB_REPLICA );
 570
 571                 $res = $db->select(
 572                         'watchlist',
 573                         [ 'wl_namespace', 'wl_title', 'wl_notificationtimestamp' ],
 574                         [ 'wl_user' => $user->getId() ],
 575                         __METHOD__,
 576                         $dbOptions
 577                 );
 578
 579                 $watchedItems = [];
 580                 foreach ( $res as $row ) {
 581                         // @todo: Should we add these to the process cache?
 582                         $watchedItems[] = new WatchedItem(
 583                                 $user,
 584                                 new TitleValue( (int)$row->wl_namespace, $row->wl_title ),
 585                                 $row->wl_notificationtimestamp
 586                         );
 587                 }
 588
 589                 return $watchedItems;
 590         }
 591
 592         /**
 593          * @since 1.27
 594          * @param User $user
 595          * @param LinkTarget $target
 596          * @return bool
 597          */
 598         public function isWatched( User $user, LinkTarget $target ) {
 599                 return (bool)$this->getWatchedItem( $user, $target );
 600         }
 601
 602         /**
 603          * @since 1.27
 604          * @param User $user
 605          * @param LinkTarget[] $targets
 606          * @return array
 607          */
 608         public function getNotificationTimestampsBatch( User $user, array $targets ) {
 609                 $timestamps = [];
 610                 foreach ( $targets as $target ) {
 611                         $timestamps[$target->getNamespace()][$target->getDBkey()] = false;
 612                 }
 613
 614                 if ( $user->isAnon() ) {
 615                         return $timestamps;
 616                 }
 617
 618                 $targetsToLoad = [];
 619                 foreach ( $targets as $target ) {
 620                         $cachedItem = $this->getCached( $user, $target );
 621                         if ( $cachedItem ) {
 622                                 $timestamps[$target->getNamespace()][$target->getDBkey()] =
 623                                         $cachedItem->getNotificationTimestamp();
 624                         } else {
 625                                 $targetsToLoad[] = $target;
 626                         }
 627                 }
 628
 629                 if ( !$targetsToLoad ) {
 630                         return $timestamps;
 631                 }
 632
 633                 $dbr = $this->getConnectionRef( DB_REPLICA );
 634
 635                 $lb = new LinkBatch( $targetsToLoad );
 636                 $res = $dbr->select(
 637                         'watchlist',
 638                         [ 'wl_namespace', 'wl_title', 'wl_notificationtimestamp' ],
 639                         [
 640                                 $lb->constructSet( 'wl', $dbr ),
 641                                 'wl_user' => $user->getId(),
 642                         ],
 643                         __METHOD__
 644                 );
 645
 646                 foreach ( $res as $row ) {
 647                         $timestamps[$row->wl_namespace][$row->wl_title] =
 648                                 wfTimestampOrNull( TS_MW, $row->wl_notificationtimestamp );
 649                 }
 650
 651                 return $timestamps;
 652         }
 653
 654         /**
 655          * @since 1.27
 656          * @param User $user
 657          * @param LinkTarget $target
 658          */
 659         public function addWatch( User $user, LinkTarget $target ) {
 660                 $this->addWatchBatchForUser( $user, [ $target ] );
 661         }
 662
 663         /**
 664          * @since 1.27
 665          * @param User $user
 666          * @param LinkTarget[] $targets
 667          * @return bool
 668          */
 669         public function addWatchBatchForUser( User $user, array $targets ) {
 670                 if ( $this->readOnlyMode->isReadOnly() ) {
 671                         return false;
 672                 }
 673                 // Only loggedin user can have a watchlist
 674                 if ( $user->isAnon() ) {
 675                         return false;
 676                 }
 677
 678                 if ( !$targets ) {
 679                         return true;
 680                 }
 681
 682                 $rows = [];
 683                 $items = [];
 684                 foreach ( $targets as $target ) {
 685                         $rows[] = [
 686                                 'wl_user' => $user->getId(),
 687                                 'wl_namespace' => $target->getNamespace(),
 688                                 'wl_title' => $target->getDBkey(),
 689                                 'wl_notificationtimestamp' => null,
 690                         ];
 691                         $items[] = new WatchedItem(
 692                                 $user,
 693                                 $target,
 694                                 null
 695                         );
 696                         $this->uncache( $user, $target );
 697                 }
 698
 699                 $dbw = $this->getConnectionRef( DB_MASTER );
 700                 foreach ( array_chunk( $rows, 100 ) as $toInsert ) {
 701                         // Use INSERT IGNORE to avoid overwriting the notification timestamp
 702                         // if there's already an entry for this page
 703                         $dbw->insert( 'watchlist', $toInsert, __METHOD__, 'IGNORE' );
 704                 }
 705                 // Update process cache to ensure skin doesn't claim that the current
 706                 // page is unwatched in the response of action=watch itself (T28292).
 707                 // This would otherwise be re-queried from a replica by isWatched().
 708                 foreach ( $items as $item ) {
 709                         $this->cache( $item );
 710                 }
 711
 712                 return true;
 713         }
 714
 715         /**
 716          * @since 1.27
 717          * @param User $user
 718          * @param LinkTarget $target
 719          * @return bool
 720          */
 721         public function removeWatch( User $user, LinkTarget $target ) {
 722                 // Only logged in user can have a watchlist
 723                 if ( $this->readOnlyMode->isReadOnly() || $user->isAnon() ) {
 724                         return false;
 725                 }
 726
 727                 $this->uncache( $user, $target );
 728
 729                 $dbw = $this->getConnectionRef( DB_MASTER );
 730                 $dbw->delete( 'watchlist',
 731                         [
 732                                 'wl_user' => $user->getId(),
 733                                 'wl_namespace' => $target->getNamespace(),
 734                                 'wl_title' => $target->getDBkey(),
 735                         ], __METHOD__
 736                 );
 737                 $success = (bool)$dbw->affectedRows();
 738
 739                 return $success;
 740         }
 741
 742         /**
 743          * @since 1.27
 744          * @param User $user
 745          * @param string|int $timestamp
 746          * @param LinkTarget[] $targets
 747          * @return bool
 748          */
 749         public function setNotificationTimestampsForUser( User $user, $timestamp, array $targets = [] ) {
 750                 // Only loggedin user can have a watchlist
 751                 if ( $user->isAnon() ) {
 752                         return false;
 753                 }
 754
 755                 $dbw = $this->getConnectionRef( DB_MASTER );
 756
 757                 $conds = [ 'wl_user' => $user->getId() ];
 758                 if ( $targets ) {
 759                         $batch = new LinkBatch( $targets );
 760                         $conds[] = $batch->constructSet( 'wl', $dbw );
 761                 }
 762
 763                 if ( $timestamp !== null ) {
 764                         $timestamp = $dbw->timestamp( $timestamp );
 765                 }
 766
 767                 $success = $dbw->update(
 768                         'watchlist',
 769                         [ 'wl_notificationtimestamp' => $timestamp ],
 770                         $conds,
 771                         __METHOD__
 772                 );
 773
 774                 $this->uncacheUser( $user );
 775
 776                 return $success;
 777         }
 778
 779         public function resetAllNotificationTimestampsForUser( User $user ) {
 780                 // Only loggedin user can have a watchlist
 781                 if ( $user->isAnon() ) {
 782                         return;
 783                 }
 784
 785                 // If the page is watched by the user (or may be watched), update the timestamp
 786                 $job = new ClearWatchlistNotificationsJob(
 787                         $user->getUserPage(),
 788                         [ 'userId'  => $user->getId(), 'casTime' => time() ]
 789                 );
 790
 791                 // Try to run this post-send
 792                 // Calls DeferredUpdates::addCallableUpdate in normal operation
 793                 call_user_func(
 794                         $this->deferredUpdatesAddCallableUpdateCallback,
 795                         function () use ( $job ) {
 796                                 $job->run();
 797                         }
 798                 );
 799         }
 800
 801         /**
 802          * @since 1.27
 803          * @param User $editor
 804          * @param LinkTarget $target
 805          * @param string|int $timestamp
 806          * @return int[]
 807          */
 808         public function updateNotificationTimestamp( User $editor, LinkTarget $target, $timestamp ) {
 809                 $dbw = $this->getConnectionRef( DB_MASTER );
 810                 $uids = $dbw->selectFieldValues(
 811                         'watchlist',
 812                         'wl_user',
 813                         [
 814                                 'wl_user != ' . intval( $editor->getId() ),
 815                                 'wl_namespace' => $target->getNamespace(),
 816                                 'wl_title' => $target->getDBkey(),
 817                                 'wl_notificationtimestamp IS NULL',
 818                         ],
 819                         __METHOD__
 820                 );
 821
 822                 $watchers = array_map( 'intval', $uids );
 823                 if ( $watchers ) {
 824                         // Update wl_notificationtimestamp for all watching users except the editor
 825                         $fname = __METHOD__;
 826                         DeferredUpdates::addCallableUpdate(
 827                                 function () use ( $timestamp, $watchers, $target, $fname ) {
 828                                         $dbw = $this->getConnectionRef( DB_MASTER );
 829                                         $ticket = $this->lbFactory->getEmptyTransactionTicket( $fname );
 830
 831                                         $watchersChunks = array_chunk( $watchers, $this->updateRowsPerQuery );
 832                                         foreach ( $watchersChunks as $watchersChunk ) {
 833                                                 $dbw->update( 'watchlist',
 834                                                         [ /* SET */
 835                                                                 'wl_notificationtimestamp' => $dbw->timestamp( $timestamp )
 836                                                         ], [ /* WHERE - TODO Use wl_id T130067 */
 837                                                                 'wl_user' => $watchersChunk,
 838                                                                 'wl_namespace' => $target->getNamespace(),
 839                                                                 'wl_title' => $target->getDBkey(),
 840                                                         ], $fname
 841                                                 );
 842                                                 if ( count( $watchersChunks ) > 1 ) {
 843                                                         $this->lbFactory->commitAndWaitForReplication(
 844                                                                 $fname, $ticket, [ 'domain' => $dbw->getDomainID() ]
 845                                                         );
 846                                                 }
 847                                         }
 848                                         $this->uncacheLinkTarget( $target );
 849                                 },
 850                                 DeferredUpdates::POSTSEND,
 851                                 $dbw
 852                         );
 853                 }
 854
 855                 return $watchers;
 856         }
 857
 858         /**
 859          * @since 1.27
 860          * @param User $user
 861          * @param Title $title
 862          * @param string $force
 863          * @param int $oldid
 864          * @return bool
 865          */
 866         public function resetNotificationTimestamp( User $user, Title $title, $force = '', $oldid = 0 ) {
 867                 // Only loggedin user can have a watchlist
 868                 if ( $this->readOnlyMode->isReadOnly() || $user->isAnon() ) {
 869                         return false;
 870                 }
 871
 872                 $item = null;
 873                 if ( $force != 'force' ) {
 874                         $item = $this->loadWatchedItem( $user, $title );
 875                         if ( !$item || $item->getNotificationTimestamp() === null ) {
 876                                 return false;
 877                         }
 878                 }
 879
 880                 // If the page is watched by the user (or may be watched), update the timestamp
 881                 $job = new ActivityUpdateJob(
 882                         $title,
 883                         [
 884                                 'type'      => 'updateWatchlistNotification',
 885                                 'userid'    => $user->getId(),
 886                                 'notifTime' => $this->getNotificationTimestamp( $user, $title, $item, $force, $oldid ),
 887                                 'curTime'   => time()
 888                         ]
 889                 );
 890
 891                 // Try to run this post-send
 892                 // Calls DeferredUpdates::addCallableUpdate in normal operation
 893                 call_user_func(
 894                         $this->deferredUpdatesAddCallableUpdateCallback,
 895                         function () use ( $job ) {
 896                                 $job->run();
 897                         }
 898                 );
 899
 900                 $this->uncache( $user, $title );
 901
 902                 return true;
 903         }
 904
 905         private function getNotificationTimestamp( User $user, Title $title, $item, $force, $oldid ) {
 906                 if ( !$oldid ) {
 907                         // No oldid given, assuming latest revision; clear the timestamp.
 908                         return null;
 909                 }
 910
 911                 if ( !$title->getNextRevisionID( $oldid ) ) {
 912                         // Oldid given and is the latest revision for this title; clear the timestamp.
 913                         return null;
 914                 }
 915
 916                 if ( $item === null ) {
 917                         $item = $this->loadWatchedItem( $user, $title );
 918                 }
 919
 920                 if ( !$item ) {
 921                         // This can only happen if $force is enabled.
 922                         return null;
 923                 }
 924
 925                 // Oldid given and isn't the latest; update the timestamp.
 926                 // This will result in no further notification emails being sent!
 927                 // Calls Revision::getTimestampFromId in normal operation
 928                 $notificationTimestamp = call_user_func(
 929                         $this->revisionGetTimestampFromIdCallback,
 930                         $title,
 931                         $oldid
 932                 );
 933
 934                 // We need to go one second to the future because of various strict comparisons
 935                 // throughout the codebase
 936                 $ts = new MWTimestamp( $notificationTimestamp );
 937                 $ts->timestamp->add( new DateInterval( 'PT1S' ) );
 938                 $notificationTimestamp = $ts->getTimestamp( TS_MW );
 939
 940                 if ( $notificationTimestamp < $item->getNotificationTimestamp() ) {
 941                         if ( $force != 'force' ) {
 942                                 return false;
 943                         } else {
 944                                 // This is a little silly…
 945                                 return $item->getNotificationTimestamp();
 946                         }
 947                 }
 948
 949                 return $notificationTimestamp;
 950         }
 951
 952         /**
 953          * @since 1.27
 954          * @param User $user
 955          * @param int|null $unreadLimit
 956          * @return int|bool
 957          */
 958         public function countUnreadNotifications( User $user, $unreadLimit = null ) {
 959                 $queryOptions = [];
 960                 if ( $unreadLimit !== null ) {
 961                         $unreadLimit = (int)$unreadLimit;
 962                         $queryOptions['LIMIT'] = $unreadLimit;
 963                 }
 964
 965                 $dbr = $this->getConnectionRef( DB_REPLICA );
 966                 $rowCount = $dbr->selectRowCount(
 967                         'watchlist',
 968                         '1',
 969                         [
 970                                 'wl_user' => $user->getId(),
 971                                 'wl_notificationtimestamp IS NOT NULL',
 972                         ],
 973                         __METHOD__,
 974                         $queryOptions
 975                 );
 976
 977                 if ( !isset( $unreadLimit ) ) {
 978                         return $rowCount;
 979                 }
 980
 981                 if ( $rowCount >= $unreadLimit ) {
 982                         return true;
 983                 }
 984
 985                 return $rowCount;
 986         }
 987
 988         /**
 989          * @since 1.27
 990          * @param LinkTarget $oldTarget
 991          * @param LinkTarget $newTarget
 992          */
 993         public function duplicateAllAssociatedEntries( LinkTarget $oldTarget, LinkTarget $newTarget ) {
 994                 $oldTarget = Title::newFromLinkTarget( $oldTarget );
 995                 $newTarget = Title::newFromLinkTarget( $newTarget );
 996
 997                 $this->duplicateEntry( $oldTarget->getSubjectPage(), $newTarget->getSubjectPage() );
 998                 $this->duplicateEntry( $oldTarget->getTalkPage(), $newTarget->getTalkPage() );
 999         }
1000
1001         /**
1002          * @since 1.27
1003          * @param LinkTarget $oldTarget
1004          * @param LinkTarget $newTarget
1005          */
1006         public function duplicateEntry( LinkTarget $oldTarget, LinkTarget $newTarget ) {
1007                 $dbw = $this->getConnectionRef( DB_MASTER );
1008
1009                 $result = $dbw->select(
1010                         'watchlist',
1011                         [ 'wl_user', 'wl_notificationtimestamp' ],
1012                         [
1013                                 'wl_namespace' => $oldTarget->getNamespace(),
1014                                 'wl_title' => $oldTarget->getDBkey(),
1015                         ],
1016                         __METHOD__,
1017                         [ 'FOR UPDATE' ]
1018                 );
1019
1020                 $newNamespace = $newTarget->getNamespace();
1021                 $newDBkey = $newTarget->getDBkey();
1022
1023                 # Construct array to replace into the watchlist
1024                 $values = [];
1025                 foreach ( $result as $row ) {
1026                         $values[] = [
1027                                 'wl_user' => $row->wl_user,
1028                                 'wl_namespace' => $newNamespace,
1029                                 'wl_title' => $newDBkey,
1030                                 'wl_notificationtimestamp' => $row->wl_notificationtimestamp,
1031                         ];
1032                 }
1033
1034                 if ( !empty( $values ) ) {
1035                         # Perform replace
1036                         # Note that multi-row replace is very efficient for MySQL but may be inefficient for
1037                         # some other DBMSes, mostly due to poor simulation by us
1038                         $dbw->replace(
1039                                 'watchlist',
1040                                 [ [ 'wl_user', 'wl_namespace', 'wl_title' ] ],
1041                                 $values,
1042                                 __METHOD__
1043                         );
1044                 }
1045         }
1046
1047 }