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
;
12 * Storage layer class for WatchedItems.
13 * Database interaction & caching
14 * TODO caching should be factored out into a CachingWatchedItemStore class
19 class WatchedItemStore
implements WatchedItemStoreInterface
, StatsdAwareInterface
{
29 private $loadBalancer;
44 private $readOnlyMode;
54 private $latestUpdateCache;
57 * @var array[] Looks like $cacheIndex[Namespace ID][Target DB Key][User Id] => 'key'
58 * The index is needed so that on mass changes all relevant items can be un-cached.
59 * For example: Clearing a users watchlist of all items or updating notification timestamps
60 * for all users watching a single target.
62 private $cacheIndex = [];
67 private $deferredUpdatesAddCallableUpdateCallback;
72 private $revisionGetTimestampFromIdCallback;
77 private $updateRowsPerQuery;
80 * @var StatsdDataFactoryInterface
85 * @param ILBFactory $lbFactory
86 * @param JobQueueGroup $queueGroup
87 * @param BagOStuff $stash
88 * @param HashBagOStuff $cache
89 * @param ReadOnlyMode $readOnlyMode
90 * @param int $updateRowsPerQuery
92 public function __construct(
93 ILBFactory
$lbFactory,
94 JobQueueGroup
$queueGroup,
97 ReadOnlyMode
$readOnlyMode,
100 $this->lbFactory
= $lbFactory;
101 $this->loadBalancer
= $lbFactory->getMainLB();
102 $this->queueGroup
= $queueGroup;
103 $this->stash
= $stash;
104 $this->cache
= $cache;
105 $this->readOnlyMode
= $readOnlyMode;
106 $this->stats
= new NullStatsdDataFactory();
107 $this->deferredUpdatesAddCallableUpdateCallback
=
108 [ DeferredUpdates
::class, 'addCallableUpdate' ];
109 $this->revisionGetTimestampFromIdCallback
=
110 [ Revision
::class, 'getTimestampFromId' ];
111 $this->updateRowsPerQuery
= $updateRowsPerQuery;
113 $this->latestUpdateCache
= new HashBagOStuff( [ 'maxKeys' => 3 ] );
117 * @param StatsdDataFactoryInterface $stats
119 public function setStatsdDataFactory( StatsdDataFactoryInterface
$stats ) {
120 $this->stats
= $stats;
124 * Overrides the DeferredUpdates::addCallableUpdate callback
125 * This is intended for use while testing and will fail if MW_PHPUNIT_TEST is not defined.
127 * @param callable $callback
129 * @see DeferredUpdates::addCallableUpdate for callback signiture
131 * @return ScopedCallback to reset the overridden value
132 * @throws MWException
134 public function overrideDeferredUpdatesAddCallableUpdateCallback( callable
$callback ) {
135 if ( !defined( 'MW_PHPUNIT_TEST' ) ) {
136 throw new MWException(
137 'Cannot override DeferredUpdates::addCallableUpdate callback in operation.'
140 $previousValue = $this->deferredUpdatesAddCallableUpdateCallback
;
141 $this->deferredUpdatesAddCallableUpdateCallback
= $callback;
142 return new ScopedCallback( function () use ( $previousValue ) {
143 $this->deferredUpdatesAddCallableUpdateCallback
= $previousValue;
148 * Overrides the Revision::getTimestampFromId callback
149 * This is intended for use while testing and will fail if MW_PHPUNIT_TEST is not defined.
151 * @param callable $callback
152 * @see Revision::getTimestampFromId for callback signiture
154 * @return ScopedCallback to reset the overridden value
155 * @throws MWException
157 public function overrideRevisionGetTimestampFromIdCallback( callable
$callback ) {
158 if ( !defined( 'MW_PHPUNIT_TEST' ) ) {
159 throw new MWException(
160 'Cannot override Revision::getTimestampFromId callback in operation.'
163 $previousValue = $this->revisionGetTimestampFromIdCallback
;
164 $this->revisionGetTimestampFromIdCallback
= $callback;
165 return new ScopedCallback( function () use ( $previousValue ) {
166 $this->revisionGetTimestampFromIdCallback
= $previousValue;
170 private function getCacheKey( User
$user, LinkTarget
$target ) {
171 return $this->cache
->makeKey(
172 (string)$target->getNamespace(),
174 (string)$user->getId()
178 private function cache( WatchedItem
$item ) {
179 $user = $item->getUser();
180 $target = $item->getLinkTarget();
181 $key = $this->getCacheKey( $user, $target );
182 $this->cache
->set( $key, $item );
183 $this->cacheIndex
[$target->getNamespace()][$target->getDBkey()][$user->getId()] = $key;
184 $this->stats
->increment( 'WatchedItemStore.cache' );
187 private function uncache( User
$user, LinkTarget
$target ) {
188 $this->cache
->delete( $this->getCacheKey( $user, $target ) );
189 unset( $this->cacheIndex
[$target->getNamespace()][$target->getDBkey()][$user->getId()] );
190 $this->stats
->increment( 'WatchedItemStore.uncache' );
193 private function uncacheLinkTarget( LinkTarget
$target ) {
194 $this->stats
->increment( 'WatchedItemStore.uncacheLinkTarget' );
195 if ( !isset( $this->cacheIndex
[$target->getNamespace()][$target->getDBkey()] ) ) {
198 foreach ( $this->cacheIndex
[$target->getNamespace()][$target->getDBkey()] as $key ) {
199 $this->stats
->increment( 'WatchedItemStore.uncacheLinkTarget.items' );
200 $this->cache
->delete( $key );
204 private function uncacheUser( User
$user ) {
205 $this->stats
->increment( 'WatchedItemStore.uncacheUser' );
206 foreach ( $this->cacheIndex
as $ns => $dbKeyArray ) {
207 foreach ( $dbKeyArray as $dbKey => $userArray ) {
208 if ( isset( $userArray[$user->getId()] ) ) {
209 $this->stats
->increment( 'WatchedItemStore.uncacheUser.items' );
210 $this->cache
->delete( $userArray[$user->getId()] );
215 $pageSeenKey = $this->getPageSeenTimestampsKey( $user );
216 $this->latestUpdateCache
->delete( $pageSeenKey );
217 $this->stash
->delete( $pageSeenKey );
222 * @param LinkTarget $target
224 * @return WatchedItem|false
226 private function getCached( User
$user, LinkTarget
$target ) {
227 return $this->cache
->get( $this->getCacheKey( $user, $target ) );
231 * Return an array of conditions to select or update the appropriate database
235 * @param LinkTarget $target
239 private function dbCond( User
$user, LinkTarget
$target ) {
241 'wl_user' => $user->getId(),
242 'wl_namespace' => $target->getNamespace(),
243 'wl_title' => $target->getDBkey(),
248 * @param int $dbIndex DB_MASTER or DB_REPLICA
251 * @throws MWException
253 private function getConnectionRef( $dbIndex ) {
254 return $this->loadBalancer
->getConnectionRef( $dbIndex, [ 'watchlist' ] );
258 * Deletes ALL watched items for the given user when under
259 * $updateRowsPerQuery entries exist.
265 * @return bool true on success, false when too many items are watched
267 public function clearUserWatchedItems( User
$user ) {
268 if ( $this->countWatchedItems( $user ) > $this->updateRowsPerQuery
) {
272 $dbw = $this->loadBalancer
->getConnectionRef( DB_MASTER
);
275 [ 'wl_user' => $user->getId() ],
278 $this->uncacheAllItemsForUser( $user );
283 private function uncacheAllItemsForUser( User
$user ) {
284 $userId = $user->getId();
285 foreach ( $this->cacheIndex
as $ns => $dbKeyIndex ) {
286 foreach ( $dbKeyIndex as $dbKey => $userIndex ) {
287 if ( array_key_exists( $userId, $userIndex ) ) {
288 $this->cache
->delete( $userIndex[$userId] );
289 unset( $this->cacheIndex
[$ns][$dbKey][$userId] );
294 // Cleanup empty cache keys
295 foreach ( $this->cacheIndex
as $ns => $dbKeyIndex ) {
296 foreach ( $dbKeyIndex as $dbKey => $userIndex ) {
297 if ( empty( $this->cacheIndex
[$ns][$dbKey] ) ) {
298 unset( $this->cacheIndex
[$ns][$dbKey] );
301 if ( empty( $this->cacheIndex
[$ns] ) ) {
302 unset( $this->cacheIndex
[$ns] );
308 * Queues a job that will clear the users watchlist using the Job Queue.
314 public function clearUserWatchedItemsUsingJobQueue( User
$user ) {
315 $job = ClearUserWatchlistJob
::newForUser( $user, $this->getMaxId() );
316 $this->queueGroup
->push( $job );
321 * @return int The maximum current wl_id
323 public function getMaxId() {
324 $dbr = $this->getConnectionRef( DB_REPLICA
);
325 return (int)$dbr->selectField(
338 public function countWatchedItems( User
$user ) {
339 $dbr = $this->getConnectionRef( DB_REPLICA
);
340 $return = (int)$dbr->selectField(
344 'wl_user' => $user->getId()
354 * @param LinkTarget $target
357 public function countWatchers( LinkTarget
$target ) {
358 $dbr = $this->getConnectionRef( DB_REPLICA
);
359 $return = (int)$dbr->selectField(
363 'wl_namespace' => $target->getNamespace(),
364 'wl_title' => $target->getDBkey(),
374 * @param LinkTarget $target
375 * @param string|int $threshold
378 public function countVisitingWatchers( LinkTarget
$target, $threshold ) {
379 $dbr = $this->getConnectionRef( DB_REPLICA
);
380 $visitingWatchers = (int)$dbr->selectField(
384 'wl_namespace' => $target->getNamespace(),
385 'wl_title' => $target->getDBkey(),
386 'wl_notificationtimestamp >= ' .
387 $dbr->addQuotes( $dbr->timestamp( $threshold ) ) .
388 ' OR wl_notificationtimestamp IS NULL'
393 return $visitingWatchers;
398 * @param TitleValue[] $titles
400 * @throws MWException
402 public function removeWatchBatchForUser( User
$user, array $titles ) {
403 if ( $this->readOnlyMode
->isReadOnly() ) {
406 if ( $user->isAnon() ) {
413 $rows = $this->getTitleDbKeysGroupedByNamespace( $titles );
414 $this->uncacheTitlesForUser( $user, $titles );
416 $dbw = $this->getConnectionRef( DB_MASTER
);
417 $ticket = count( $titles ) > $this->updateRowsPerQuery ?
418 $this->lbFactory
->getEmptyTransactionTicket( __METHOD__
) : null;
421 // Batch delete items per namespace.
422 foreach ( $rows as $namespace => $namespaceTitles ) {
423 $rowBatches = array_chunk( $namespaceTitles, $this->updateRowsPerQuery
);
424 foreach ( $rowBatches as $toDelete ) {
425 $dbw->delete( 'watchlist', [
426 'wl_user' => $user->getId(),
427 'wl_namespace' => $namespace,
428 'wl_title' => $toDelete
430 $affectedRows +
= $dbw->affectedRows();
432 $this->lbFactory
->commitAndWaitForReplication( __METHOD__
, $ticket );
437 return (bool)$affectedRows;
442 * @param LinkTarget[] $targets
443 * @param array $options
446 public function countWatchersMultiple( array $targets, array $options = [] ) {
447 $dbOptions = [ 'GROUP BY' => [ 'wl_namespace', 'wl_title' ] ];
449 $dbr = $this->getConnectionRef( DB_REPLICA
);
451 if ( array_key_exists( 'minimumWatchers', $options ) ) {
452 $dbOptions['HAVING'] = 'COUNT(*) >= ' . (int)$options['minimumWatchers'];
455 $lb = new LinkBatch( $targets );
458 [ 'wl_title', 'wl_namespace', 'watchers' => 'COUNT(*)' ],
459 [ $lb->constructSet( 'wl', $dbr ) ],
465 foreach ( $targets as $linkTarget ) {
466 $watchCounts[$linkTarget->getNamespace()][$linkTarget->getDBkey()] = 0;
469 foreach ( $res as $row ) {
470 $watchCounts[$row->wl_namespace
][$row->wl_title
] = (int)$row->watchers
;
478 * @param array $targetsWithVisitThresholds
479 * @param int|null $minimumWatchers
482 public function countVisitingWatchersMultiple(
483 array $targetsWithVisitThresholds,
484 $minimumWatchers = null
486 if ( $targetsWithVisitThresholds === [] ) {
487 // No titles requested => no results returned
491 $dbr = $this->getConnectionRef( DB_REPLICA
);
493 $conds = $this->getVisitingWatchersCondition( $dbr, $targetsWithVisitThresholds );
495 $dbOptions = [ 'GROUP BY' => [ 'wl_namespace', 'wl_title' ] ];
496 if ( $minimumWatchers !== null ) {
497 $dbOptions['HAVING'] = 'COUNT(*) >= ' . (int)$minimumWatchers;
501 [ 'wl_namespace', 'wl_title', 'watchers' => 'COUNT(*)' ],
508 foreach ( $targetsWithVisitThresholds as list( $target ) ) {
509 /* @var LinkTarget $target */
510 $watcherCounts[$target->getNamespace()][$target->getDBkey()] = 0;
513 foreach ( $res as $row ) {
514 $watcherCounts[$row->wl_namespace
][$row->wl_title
] = (int)$row->watchers
;
517 return $watcherCounts;
521 * Generates condition for the query used in a batch count visiting watchers.
523 * @param IDatabase $db
524 * @param array $targetsWithVisitThresholds array of pairs (LinkTarget, last visit threshold)
527 private function getVisitingWatchersCondition(
529 array $targetsWithVisitThresholds
531 $missingTargets = [];
532 $namespaceConds = [];
533 foreach ( $targetsWithVisitThresholds as list( $target, $threshold ) ) {
534 if ( $threshold === null ) {
535 $missingTargets[] = $target;
538 /* @var LinkTarget $target */
539 $namespaceConds[$target->getNamespace()][] = $db->makeList( [
540 'wl_title = ' . $db->addQuotes( $target->getDBkey() ),
542 'wl_notificationtimestamp >= ' . $db->addQuotes( $db->timestamp( $threshold ) ),
543 'wl_notificationtimestamp IS NULL'
549 foreach ( $namespaceConds as $namespace => $pageConds ) {
550 $conds[] = $db->makeList( [
551 'wl_namespace = ' . $namespace,
552 '(' . $db->makeList( $pageConds, LIST_OR
) . ')'
556 if ( $missingTargets ) {
557 $lb = new LinkBatch( $missingTargets );
558 $conds[] = $lb->constructSet( 'wl', $db );
561 return $db->makeList( $conds, LIST_OR
);
567 * @param LinkTarget $target
570 public function getWatchedItem( User
$user, LinkTarget
$target ) {
571 if ( $user->isAnon() ) {
575 $cached = $this->getCached( $user, $target );
577 $this->stats
->increment( 'WatchedItemStore.getWatchedItem.cached' );
580 $this->stats
->increment( 'WatchedItemStore.getWatchedItem.load' );
581 return $this->loadWatchedItem( $user, $target );
587 * @param LinkTarget $target
588 * @return WatchedItem|bool
590 public function loadWatchedItem( User
$user, LinkTarget
$target ) {
591 // Only loggedin user can have a watchlist
592 if ( $user->isAnon() ) {
596 $dbr = $this->getConnectionRef( DB_REPLICA
);
598 $row = $dbr->selectRow(
600 'wl_notificationtimestamp',
601 $this->dbCond( $user, $target ),
609 $item = new WatchedItem(
612 $this->getLatestNotificationTimestamp( $row->wl_notificationtimestamp
, $user, $target )
614 $this->cache( $item );
622 * @param array $options
623 * @return WatchedItem[]
625 public function getWatchedItemsForUser( User
$user, array $options = [] ) {
626 $options +
= [ 'forWrite' => false ];
629 if ( array_key_exists( 'sort', $options ) ) {
631 ( in_array( $options['sort'], [ self
::SORT_ASC
, self
::SORT_DESC
] ) ),
632 '$options[\'sort\']',
633 'must be SORT_ASC or SORT_DESC'
635 $dbOptions['ORDER BY'] = [
636 "wl_namespace {$options['sort']}",
637 "wl_title {$options['sort']}"
640 $db = $this->getConnectionRef( $options['forWrite'] ? DB_MASTER
: DB_REPLICA
);
644 [ 'wl_namespace', 'wl_title', 'wl_notificationtimestamp' ],
645 [ 'wl_user' => $user->getId() ],
651 foreach ( $res as $row ) {
652 $target = new TitleValue( (int)$row->wl_namespace
, $row->wl_title
);
653 // @todo: Should we add these to the process cache?
654 $watchedItems[] = new WatchedItem(
656 new TitleValue( (int)$row->wl_namespace
, $row->wl_title
),
657 $this->getLatestNotificationTimestamp(
658 $row->wl_notificationtimestamp
, $user, $target )
662 return $watchedItems;
668 * @param LinkTarget $target
671 public function isWatched( User
$user, LinkTarget
$target ) {
672 return (bool)$this->getWatchedItem( $user, $target );
678 * @param LinkTarget[] $targets
681 public function getNotificationTimestampsBatch( User
$user, array $targets ) {
683 foreach ( $targets as $target ) {
684 $timestamps[$target->getNamespace()][$target->getDBkey()] = false;
687 if ( $user->isAnon() ) {
692 foreach ( $targets as $target ) {
693 $cachedItem = $this->getCached( $user, $target );
695 $timestamps[$target->getNamespace()][$target->getDBkey()] =
696 $cachedItem->getNotificationTimestamp();
698 $targetsToLoad[] = $target;
702 if ( !$targetsToLoad ) {
706 $dbr = $this->getConnectionRef( DB_REPLICA
);
708 $lb = new LinkBatch( $targetsToLoad );
711 [ 'wl_namespace', 'wl_title', 'wl_notificationtimestamp' ],
713 $lb->constructSet( 'wl', $dbr ),
714 'wl_user' => $user->getId(),
719 foreach ( $res as $row ) {
720 $target = new TitleValue( (int)$row->wl_namespace
, $row->wl_title
);
721 $timestamps[$row->wl_namespace
][$row->wl_title
] =
722 $this->getLatestNotificationTimestamp(
723 $row->wl_notificationtimestamp
, $user, $target );
732 * @param LinkTarget $target
733 * @throws MWException
735 public function addWatch( User
$user, LinkTarget
$target ) {
736 $this->addWatchBatchForUser( $user, [ $target ] );
742 * @param LinkTarget[] $targets
744 * @throws MWException
746 public function addWatchBatchForUser( User
$user, array $targets ) {
747 if ( $this->readOnlyMode
->isReadOnly() ) {
750 // Only logged-in user can have a watchlist
751 if ( $user->isAnon() ) {
761 foreach ( $targets as $target ) {
763 'wl_user' => $user->getId(),
764 'wl_namespace' => $target->getNamespace(),
765 'wl_title' => $target->getDBkey(),
766 'wl_notificationtimestamp' => null,
768 $items[] = new WatchedItem(
773 $this->uncache( $user, $target );
776 $dbw = $this->getConnectionRef( DB_MASTER
);
777 $ticket = count( $targets ) > $this->updateRowsPerQuery ?
778 $this->lbFactory
->getEmptyTransactionTicket( __METHOD__
) : null;
780 $rowBatches = array_chunk( $rows, $this->updateRowsPerQuery
);
781 foreach ( $rowBatches as $toInsert ) {
782 // Use INSERT IGNORE to avoid overwriting the notification timestamp
783 // if there's already an entry for this page
784 $dbw->insert( 'watchlist', $toInsert, __METHOD__
, 'IGNORE' );
785 $affectedRows +
= $dbw->affectedRows();
787 $this->lbFactory
->commitAndWaitForReplication( __METHOD__
, $ticket );
790 // Update process cache to ensure skin doesn't claim that the current
791 // page is unwatched in the response of action=watch itself (T28292).
792 // This would otherwise be re-queried from a replica by isWatched().
793 foreach ( $items as $item ) {
794 $this->cache( $item );
797 return (bool)$affectedRows;
803 * @param LinkTarget $target
805 * @throws MWException
807 public function removeWatch( User
$user, LinkTarget
$target ) {
808 return $this->removeWatchBatchForUser( $user, [ $target ] );
812 * Set the "last viewed" timestamps for certain titles on a user's watchlist.
814 * If the $targets parameter is omitted or set to [], this method simply wraps
815 * resetAllNotificationTimestampsForUser(), and in that case you should instead call that method
816 * directly; support for omitting $targets is for backwards compatibility.
818 * If $targets is omitted or set to [], timestamps will be updated for every title on the user's
819 * watchlist, and this will be done through a DeferredUpdate. If $targets is a non-empty array,
820 * only the specified titles will be updated, and this will be done immediately (not deferred).
824 * @param string|int $timestamp Value to set the "last viewed" timestamp to (null to clear)
825 * @param LinkTarget[] $targets Titles to set the timestamp for; [] means the entire watchlist
828 public function setNotificationTimestampsForUser( User
$user, $timestamp, array $targets = [] ) {
829 // Only loggedin user can have a watchlist
830 if ( $user->isAnon() ||
$this->readOnlyMode
->isReadOnly() ) {
835 // Backwards compatibility
836 $this->resetAllNotificationTimestampsForUser( $user, $timestamp );
840 $rows = $this->getTitleDbKeysGroupedByNamespace( $targets );
842 $dbw = $this->getConnectionRef( DB_MASTER
);
843 if ( $timestamp !== null ) {
844 $timestamp = $dbw->timestamp( $timestamp );
846 $ticket = $this->lbFactory
->getEmptyTransactionTicket( __METHOD__
);
847 $affectedSinceWait = 0;
849 // Batch update items per namespace
850 foreach ( $rows as $namespace => $namespaceTitles ) {
851 $rowBatches = array_chunk( $namespaceTitles, $this->updateRowsPerQuery
);
852 foreach ( $rowBatches as $toUpdate ) {
855 [ 'wl_notificationtimestamp' => $timestamp ],
857 'wl_user' => $user->getId(),
858 'wl_namespace' => $namespace,
859 'wl_title' => $toUpdate
862 $affectedSinceWait +
= $dbw->affectedRows();
863 // Wait for replication every time we've touched updateRowsPerQuery rows
864 if ( $affectedSinceWait >= $this->updateRowsPerQuery
) {
865 $this->lbFactory
->commitAndWaitForReplication( __METHOD__
, $ticket );
866 $affectedSinceWait = 0;
871 $this->uncacheUser( $user );
876 public function getLatestNotificationTimestamp( $timestamp, User
$user, LinkTarget
$target ) {
877 $timestamp = wfTimestampOrNull( TS_MW
, $timestamp );
878 if ( $timestamp === null ) {
879 return null; // no notification
882 $seenTimestamps = $this->getPageSeenTimestamps( $user );
885 $seenTimestamps->get( $this->getPageSeenKey( $target ) ) >= $timestamp
887 // If a reset job did not yet run, then the "seen" timestamp will be higher
895 * Schedule a DeferredUpdate that sets all of the "last viewed" timestamps for a given user
898 * @param string|int|null $timestamp Value to set all timestamps to, null to clear them
900 public function resetAllNotificationTimestampsForUser( User
$user, $timestamp = null ) {
901 // Only loggedin user can have a watchlist
902 if ( $user->isAnon() ) {
906 // If the page is watched by the user (or may be watched), update the timestamp
907 $job = new ClearWatchlistNotificationsJob( [
908 'userId' => $user->getId(), 'timestamp' => $timestamp, 'casTime' => time()
911 // Try to run this post-send
912 // Calls DeferredUpdates::addCallableUpdate in normal operation
914 $this->deferredUpdatesAddCallableUpdateCallback
,
915 function () use ( $job ) {
923 * @param User $editor
924 * @param LinkTarget $target
925 * @param string|int $timestamp
928 public function updateNotificationTimestamp( User
$editor, LinkTarget
$target, $timestamp ) {
929 $dbw = $this->getConnectionRef( DB_MASTER
);
930 $uids = $dbw->selectFieldValues(
934 'wl_user != ' . intval( $editor->getId() ),
935 'wl_namespace' => $target->getNamespace(),
936 'wl_title' => $target->getDBkey(),
937 'wl_notificationtimestamp IS NULL',
942 $watchers = array_map( 'intval', $uids );
944 // Update wl_notificationtimestamp for all watching users except the editor
946 DeferredUpdates
::addCallableUpdate(
947 function () use ( $timestamp, $watchers, $target, $fname ) {
948 $dbw = $this->getConnectionRef( DB_MASTER
);
949 $ticket = $this->lbFactory
->getEmptyTransactionTicket( $fname );
951 $watchersChunks = array_chunk( $watchers, $this->updateRowsPerQuery
);
952 foreach ( $watchersChunks as $watchersChunk ) {
953 $dbw->update( 'watchlist',
955 'wl_notificationtimestamp' => $dbw->timestamp( $timestamp )
956 ], [ /* WHERE - TODO Use wl_id T130067 */
957 'wl_user' => $watchersChunk,
958 'wl_namespace' => $target->getNamespace(),
959 'wl_title' => $target->getDBkey(),
962 if ( count( $watchersChunks ) > 1 ) {
963 $this->lbFactory
->commitAndWaitForReplication(
964 $fname, $ticket, [ 'domain' => $dbw->getDomainID() ]
968 $this->uncacheLinkTarget( $target );
970 DeferredUpdates
::POSTSEND
,
981 * @param Title $title
982 * @param string $force
986 public function resetNotificationTimestamp( User
$user, Title
$title, $force = '', $oldid = 0 ) {
989 // Only loggedin user can have a watchlist
990 if ( $this->readOnlyMode
->isReadOnly() ||
$user->isAnon() ) {
994 if ( !Hooks
::run( 'BeforeResetNotificationTimestamp', [ &$user, &$title, $force, &$oldid ] ) ) {
999 if ( $force != 'force' ) {
1000 $item = $this->loadWatchedItem( $user, $title );
1001 if ( !$item ||
$item->getNotificationTimestamp() === null ) {
1006 // Get the timestamp (TS_MW) of this revision to track the latest one seen
1007 $seenTime = call_user_func(
1008 $this->revisionGetTimestampFromIdCallback
,
1010 $oldid ?
: $title->getLatestRevID()
1013 // Mark the item as read immediately in lightweight storage
1014 $this->stash
->merge(
1015 $this->getPageSeenTimestampsKey( $user ),
1016 function ( $cache, $key, $current ) use ( $title, $seenTime ) {
1017 $value = $current ?
: new MapCacheLRU( 300 );
1018 $subKey = $this->getPageSeenKey( $title );
1020 if ( $seenTime > $value->get( $subKey ) ) {
1021 // Revision is newer than the last one seen
1022 $value->set( $subKey, $seenTime );
1023 $this->latestUpdateCache
->set( $key, $value, IExpiringStore
::TTL_PROC_LONG
);
1024 } elseif ( $seenTime === false ) {
1025 // Revision does not exist
1026 $value->set( $subKey, wfTimestamp( TS_MW
) );
1027 $this->latestUpdateCache
->set( $key, $value, IExpiringStore
::TTL_PROC_LONG
);
1029 return false; // nothing to update
1034 IExpiringStore
::TTL_HOUR
1037 // If the page is watched by the user (or may be watched), update the timestamp
1038 $job = new ActivityUpdateJob(
1041 'type' => 'updateWatchlistNotification',
1042 'userid' => $user->getId(),
1043 'notifTime' => $this->getNotificationTimestamp( $user, $title, $item, $force, $oldid ),
1047 // Try to enqueue this post-send
1048 $this->queueGroup
->lazyPush( $job );
1050 $this->uncache( $user, $title );
1057 * @return MapCacheLRU|null The map contains prefixed title keys and TS_MW values
1059 private function getPageSeenTimestamps( User
$user ) {
1060 $key = $this->getPageSeenTimestampsKey( $user );
1062 return $this->latestUpdateCache
->getWithSetCallback(
1064 IExpiringStore
::TTL_PROC_LONG
,
1065 function () use ( $key ) {
1066 return $this->stash
->get( $key ) ?
: null;
1075 private function getPageSeenTimestampsKey( User
$user ) {
1076 return $this->stash
->makeGlobalKey(
1077 'watchlist-recent-updates',
1078 $this->lbFactory
->getLocalDomainID(),
1084 * @param LinkTarget $target
1087 private function getPageSeenKey( LinkTarget
$target ) {
1088 return "{$target->getNamespace()}:{$target->getDBkey()}";
1091 private function getNotificationTimestamp( User
$user, Title
$title, $item, $force, $oldid ) {
1093 // No oldid given, assuming latest revision; clear the timestamp.
1097 if ( !$title->getNextRevisionID( $oldid ) ) {
1098 // Oldid given and is the latest revision for this title; clear the timestamp.
1102 if ( $item === null ) {
1103 $item = $this->loadWatchedItem( $user, $title );
1107 // This can only happen if $force is enabled.
1111 // Oldid given and isn't the latest; update the timestamp.
1112 // This will result in no further notification emails being sent!
1113 // Calls Revision::getTimestampFromId in normal operation
1114 $notificationTimestamp = call_user_func(
1115 $this->revisionGetTimestampFromIdCallback
,
1120 // We need to go one second to the future because of various strict comparisons
1121 // throughout the codebase
1122 $ts = new MWTimestamp( $notificationTimestamp );
1123 $ts->timestamp
->add( new DateInterval( 'PT1S' ) );
1124 $notificationTimestamp = $ts->getTimestamp( TS_MW
);
1126 if ( $notificationTimestamp < $item->getNotificationTimestamp() ) {
1127 if ( $force != 'force' ) {
1130 // This is a little silly…
1131 return $item->getNotificationTimestamp();
1135 return $notificationTimestamp;
1141 * @param int|null $unreadLimit
1144 public function countUnreadNotifications( User
$user, $unreadLimit = null ) {
1145 $dbr = $this->getConnectionRef( DB_REPLICA
);
1148 if ( $unreadLimit !== null ) {
1149 $unreadLimit = (int)$unreadLimit;
1150 $queryOptions['LIMIT'] = $unreadLimit;
1154 'wl_user' => $user->getId(),
1155 'wl_notificationtimestamp IS NOT NULL'
1158 $rowCount = $dbr->selectRowCount( 'watchlist', '1', $conds, __METHOD__
, $queryOptions );
1160 if ( $unreadLimit === null ) {
1164 if ( $rowCount >= $unreadLimit ) {
1173 * @param LinkTarget $oldTarget
1174 * @param LinkTarget $newTarget
1176 public function duplicateAllAssociatedEntries( LinkTarget
$oldTarget, LinkTarget
$newTarget ) {
1177 $oldTarget = Title
::newFromLinkTarget( $oldTarget );
1178 $newTarget = Title
::newFromLinkTarget( $newTarget );
1180 $this->duplicateEntry( $oldTarget->getSubjectPage(), $newTarget->getSubjectPage() );
1181 $this->duplicateEntry( $oldTarget->getTalkPage(), $newTarget->getTalkPage() );
1186 * @param LinkTarget $oldTarget
1187 * @param LinkTarget $newTarget
1189 public function duplicateEntry( LinkTarget
$oldTarget, LinkTarget
$newTarget ) {
1190 $dbw = $this->getConnectionRef( DB_MASTER
);
1192 $result = $dbw->select(
1194 [ 'wl_user', 'wl_notificationtimestamp' ],
1196 'wl_namespace' => $oldTarget->getNamespace(),
1197 'wl_title' => $oldTarget->getDBkey(),
1203 $newNamespace = $newTarget->getNamespace();
1204 $newDBkey = $newTarget->getDBkey();
1206 # Construct array to replace into the watchlist
1208 foreach ( $result as $row ) {
1210 'wl_user' => $row->wl_user
,
1211 'wl_namespace' => $newNamespace,
1212 'wl_title' => $newDBkey,
1213 'wl_notificationtimestamp' => $row->wl_notificationtimestamp
,
1217 if ( !empty( $values ) ) {
1219 # Note that multi-row replace is very efficient for MySQL but may be inefficient for
1220 # some other DBMSes, mostly due to poor simulation by us
1223 [ [ 'wl_user', 'wl_namespace', 'wl_title' ] ],
1231 * @param LinkTarget[] $titles
1234 private function getTitleDbKeysGroupedByNamespace( array $titles ) {
1236 foreach ( $titles as $title ) {
1237 // Group titles by namespace.
1238 $rows[ $title->getNamespace() ][] = $title->getDBkey();
1245 * @param Title[] $titles
1247 private function uncacheTitlesForUser( User
$user, array $titles ) {
1248 foreach ( $titles as $title ) {
1249 $this->uncache( $user, $title );