ChangeTagsStore.php

Go to the documentation of this file.

<?php
namespace MediaWiki\ChangeTags;
 
use BadMethodCallException;
use InvalidArgumentException;
use ManualLogEntry;
use MediaWiki\Config\ServiceOptions;
use MediaWiki\HookContainer\HookContainer;
use MediaWiki\HookContainer\HookRunner;
use MediaWiki\MainConfigNames;
use MediaWiki\Status\Status;
use MediaWiki\Storage\NameTableAccessException;
use MediaWiki\Storage\NameTableStore;
use MediaWiki\Title\Title;
use MediaWiki\User\UserFactory;
use MediaWiki\User\UserIdentity;
use Psr\Log\LoggerInterface;
use RecentChange;
use WANObjectCache;
use Wikimedia\Rdbms\Database;
use Wikimedia\Rdbms\IConnectionProvider;
use Wikimedia\Rdbms\IReadableDatabase;
use Wikimedia\Rdbms\SelectQueryBuilder;
 
class ChangeTagsStore {
 
    private const CHANGE_TAG = 'change_tag';
 
    private const CHANGE_TAG_DEF = 'change_tag_def';
 
    public const DISPLAY_TABLE_ALIAS = 'changetagdisplay';
 
    public const CONSTRUCTOR_OPTIONS = [
        MainConfigNames::SoftwareTags,
        MainConfigNames::UseTagFilter,
    ];
 
    private const DEFINED_SOFTWARE_TAGS = [
        'mw-contentmodelchange',
        'mw-new-redirect',
        'mw-removed-redirect',
        'mw-changed-redirect-target',
        'mw-blank',
        'mw-replace',
        'mw-rollback',
        'mw-undo',
        'mw-manual-revert',
        'mw-reverted',
        'mw-server-side-upload',
    ];
 
    private IConnectionProvider $dbProvider;
    private LoggerInterface $logger;
    private ServiceOptions $options;
    private NameTableStore $changeTagDefStore;
    private WANObjectCache $wanCache;
    private HookRunner $hookRunner;
    private UserFactory $userFactory;
    private HookContainer $hookContainer;
 
    public function __construct(
        IConnectionProvider $dbProvider,
        NameTableStore $changeTagDefStore,
        WANObjectCache $wanCache,
        HookContainer $hookContainer,
        LoggerInterface $logger,
        UserFactory $userFactory,
        ServiceOptions $options
    ) {
        $options->assertRequiredOptions( self::CONSTRUCTOR_OPTIONS );
        $this->dbProvider = $dbProvider;
        $this->logger = $logger;
        $this->options = $options;
        $this->changeTagDefStore = $changeTagDefStore;
        $this->wanCache = $wanCache;
        $this->hookContainer = $hookContainer;
        $this->userFactory = $userFactory;
        $this->hookRunner = new HookRunner( $hookContainer );
    }
 
    public function getSoftwareTags( $all = false ): array {
        $coreTags = $this->options->get( MainConfigNames::SoftwareTags );
        if ( !is_array( $coreTags ) ) {
            $this->logger->warning( 'wgSoftwareTags should be associative array of enabled tags.
            Please refer to documentation for the list of tags you can enable' );
            return [];
        }
 
        $availableSoftwareTags = !$all ?
            array_keys( array_filter( $coreTags ) ) :
            array_keys( $coreTags );
 
        $softwareTags = array_intersect(
            $availableSoftwareTags,
            self::DEFINED_SOFTWARE_TAGS
        );
 
        return $softwareTags;
    }
 
    public function getTagsWithData(
        IReadableDatabase $db, $rc_id = null, $rev_id = null, $log_id = null
    ): array {
        if ( !$rc_id && !$rev_id && !$log_id ) {
            throw new BadMethodCallException(
                'At least one of: RCID, revision ID, and log ID MUST be ' .
                'specified when loading tags from a change!' );
        }
 
        $conds = array_filter(
            [
                'ct_rc_id' => $rc_id,
                'ct_rev_id' => $rev_id,
                'ct_log_id' => $log_id,
            ]
        );
        $result = $db->newSelectQueryBuilder()
            ->select( [ 'ct_tag_id', 'ct_params' ] )
            ->from( self::CHANGE_TAG )
            ->where( $conds )
            ->caller( __METHOD__ )
            ->fetchResultSet();
 
        $tags = [];
        foreach ( $result as $row ) {
            $tagName = $this->changeTagDefStore->getName( (int)$row->ct_tag_id );
            $tags[$tagName] = $row->ct_params;
        }
 
        return $tags;
    }
 
    public function makeTagSummarySubquery( $tables ) {
        // Normalize to arrays
        $tables = (array)$tables;
 
        // Figure out which ID field to use
        if ( in_array( 'recentchanges', $tables ) ) {
            $join_cond = 'ct_rc_id=rc_id';
        } elseif ( in_array( 'logging', $tables ) ) {
            $join_cond = 'ct_log_id=log_id';
        } elseif ( in_array( 'revision', $tables ) ) {
            $join_cond = 'ct_rev_id=rev_id';
        } elseif ( in_array( 'archive', $tables ) ) {
            $join_cond = 'ct_rev_id=ar_rev_id';
        } else {
            throw new InvalidArgumentException( 'Unable to determine appropriate JOIN condition for tagging.' );
        }
 
        $tagTables = [ self::CHANGE_TAG, self::CHANGE_TAG_DEF ];
        $join_cond_ts_tags = [ self::CHANGE_TAG_DEF => [ 'JOIN', 'ct_tag_id=ctd_id' ] ];
        $field = 'ctd_name';
 
        return $this->dbProvider->getReplicaDatabase()
            ->buildGroupConcatField( ',', $tagTables, $field, $join_cond, $join_cond_ts_tags );
    }
 
    public function defineTag( $tag ) {
        $dbw = $this->dbProvider->getPrimaryDatabase();
        $dbw->newInsertQueryBuilder()
            ->insertInto( self::CHANGE_TAG_DEF )
            ->row( [
                'ctd_name' => $tag,
                'ctd_user_defined' => 1,
                'ctd_count' => 0
            ] )
            ->onDuplicateKeyUpdate()
            ->uniqueIndexFields( [ 'ctd_name' ] )
            ->set( [ 'ctd_user_defined' => 1 ] )
            ->caller( __METHOD__ )->execute();
 
        // clear the memcache of defined tags
        $this->purgeTagCacheAll();
    }
 
    public function undefineTag( $tag ) {
        $dbw = $this->dbProvider->getPrimaryDatabase();
 
        $dbw->newUpdateQueryBuilder()
            ->update( self::CHANGE_TAG_DEF )
            ->set( [ 'ctd_user_defined' => 0 ] )
            ->where( [ 'ctd_name' => $tag ] )
            ->caller( __METHOD__ )->execute();
 
        $dbw->newDeleteQueryBuilder()
            ->deleteFrom( self::CHANGE_TAG_DEF )
            ->where( [ 'ctd_name' => $tag, 'ctd_count' => 0 ] )
            ->caller( __METHOD__ )->execute();
 
        // clear the memcache of defined tags
        $this->purgeTagCacheAll();
    }
 
    public function logTagManagementAction( string $action, string $tag, string $reason,
        UserIdentity $user, $tagCount = null, array $logEntryTags = []
    ) {
        $dbw = $this->dbProvider->getPrimaryDatabase();
 
        $logEntry = new ManualLogEntry( 'managetags', $action );
        $logEntry->setPerformer( $user );
        // target page is not relevant, but it has to be set, so we just put in
        // the title of Special:Tags
        $logEntry->setTarget( Title::newFromText( 'Special:Tags' ) );
        $logEntry->setComment( $reason );
 
        $params = [ '4::tag' => $tag ];
        if ( $tagCount !== null ) {
            $params['5:number:count'] = $tagCount;
        }
        $logEntry->setParameters( $params );
        $logEntry->setRelations( [ 'Tag' => $tag ] );
        $logEntry->addTags( $logEntryTags );
 
        $logId = $logEntry->insert( $dbw );
        $logEntry->publish( $logId );
        return $logId;
    }
 
    public function deleteTagEverywhere( $tag ) {
        $dbw = $this->dbProvider->getPrimaryDatabase();
        $dbw->startAtomic( __METHOD__ );
 
        // fetch tag id, this must be done before calling undefineTag(), see T225564
        $tagId = $this->changeTagDefStore->getId( $tag );
 
        // set ctd_user_defined = 0
        $this->undefineTag( $tag );
 
        // delete from change_tag
        $dbw->newDeleteQueryBuilder()
            ->deleteFrom( self::CHANGE_TAG )
            ->where( [ 'ct_tag_id' => $tagId ] )
            ->caller( __METHOD__ )->execute();
        $dbw->newDeleteQueryBuilder()
            ->deleteFrom( self::CHANGE_TAG_DEF )
            ->where( [ 'ctd_name' => $tag ] )
            ->caller( __METHOD__ )->execute();
        $dbw->endAtomic( __METHOD__ );
 
        // give extensions a chance
        $status = Status::newGood();
        $this->hookRunner->onChangeTagAfterDelete( $tag, $status );
        // let's not allow error results, as the actual tag deletion succeeded
        if ( !$status->isOK() ) {
            $this->logger->debug( 'ChangeTagAfterDelete error condition downgraded to warning' );
            $status->setOK( true );
        }
 
        // clear the memcache of defined tags
        $this->purgeTagCacheAll();
 
        return $status;
    }
 
    public function purgeTagCacheAll() {
        $this->wanCache->touchCheckKey( $this->wanCache->makeKey( 'active-tags' ) );
        $this->wanCache->touchCheckKey( $this->wanCache->makeKey( 'valid-tags-db' ) );
        $this->wanCache->touchCheckKey( $this->wanCache->makeKey( 'valid-tags-hook' ) );
        $this->wanCache->touchCheckKey( $this->wanCache->makeKey( 'tags-usage-statistics' ) );
 
        $this->changeTagDefStore->reloadMap();
    }
 
    public function tagUsageStatistics(): array {
        $fname = __METHOD__;
        $dbProvider = $this->dbProvider;
 
        return $this->wanCache->getWithSetCallback(
            $this->wanCache->makeKey( 'tags-usage-statistics' ),
            WANObjectCache::TTL_MINUTE * 5,
            static function ( $oldValue, &$ttl, array &$setOpts ) use ( $fname, $dbProvider ) {
                $dbr = $dbProvider->getReplicaDatabase();
                $res = $dbr->newSelectQueryBuilder()
                    ->select( [ 'ctd_name', 'ctd_count' ] )
                    ->from( self::CHANGE_TAG_DEF )
                    ->orderBy( 'ctd_count', SelectQueryBuilder::SORT_DESC )
                    ->caller( $fname )
                    ->fetchResultSet();
 
                $out = [];
                foreach ( $res as $row ) {
                    $out[$row->ctd_name] = $row->ctd_count;
                }
 
                return $out;
            },
            [
                'checkKeys' => [ $this->wanCache->makeKey( 'tags-usage-statistics' ) ],
                'lockTSE' => WANObjectCache::TTL_MINUTE * 5,
                'pcTTL' => WANObjectCache::TTL_PROC_LONG
            ]
        );
    }
 
    public function listExplicitlyDefinedTags() {
        $fname = __METHOD__;
        $dbProvider = $this->dbProvider;
 
        return $this->wanCache->getWithSetCallback(
            $this->wanCache->makeKey( 'valid-tags-db' ),
            WANObjectCache::TTL_MINUTE * 5,
            static function ( $oldValue, &$ttl, array &$setOpts ) use ( $fname, $dbProvider ) {
                $dbr = $dbProvider->getReplicaDatabase();
                $setOpts += Database::getCacheSetOptions( $dbr );
                $tags = $dbr->newSelectQueryBuilder()
                    ->select( 'ctd_name' )
                    ->from( self::CHANGE_TAG_DEF )
                    ->where( [ 'ctd_user_defined' => 1 ] )
                    ->caller( $fname )
                    ->fetchFieldValues();
 
                return array_unique( $tags );
            },
            [
                'checkKeys' => [ $this->wanCache->makeKey( 'valid-tags-db' ) ],
                'lockTSE' => WANObjectCache::TTL_MINUTE * 5,
                'pcTTL' => WANObjectCache::TTL_PROC_LONG
            ]
        );
    }
 
    public function listSoftwareDefinedTags() {
        // core defined tags
        $tags = $this->getSoftwareTags( true );
        if ( !$this->hookContainer->isRegistered( 'ListDefinedTags' ) ) {
            return $tags;
        }
        $hookRunner = $this->hookRunner;
        $dbProvider = $this->dbProvider;
        return $this->wanCache->getWithSetCallback(
            $this->wanCache->makeKey( 'valid-tags-hook' ),
            WANObjectCache::TTL_MINUTE * 5,
            static function ( $oldValue, &$ttl, array &$setOpts ) use ( $tags, $hookRunner, $dbProvider ) {
                $setOpts += Database::getCacheSetOptions( $dbProvider->getReplicaDatabase() );
                $hookRunner->onListDefinedTags( $tags );
                return array_unique( $tags );
            },
            [
                'checkKeys' => [ $this->wanCache->makeKey( 'valid-tags-hook' ) ],
                'lockTSE' => WANObjectCache::TTL_MINUTE * 5,
                'pcTTL' => WANObjectCache::TTL_PROC_LONG
            ]
        );
    }
 
    public function getTags( IReadableDatabase $db, $rc_id = null, $rev_id = null, $log_id = null ) {
        return array_keys( $this->getTagsWithData( $db, $rc_id, $rev_id, $log_id ) );
    }
 
    public function listDefinedTags() {
        $tags1 = $this->listExplicitlyDefinedTags();
        $tags2 = $this->listSoftwareDefinedTags();
        return array_values( array_unique( array_merge( $tags1, $tags2 ) ) );
    }
 
    public function updateTags( $tagsToAdd, $tagsToRemove, &$rc_id = null,
        &$rev_id = null, &$log_id = null, $params = null, RecentChange $rc = null,
        UserIdentity $user = null
    ) {
        $tagsToAdd = array_filter(
            (array)$tagsToAdd, // Make sure we're submitting all tags...
            static function ( $value ) {
                return ( $value ?? '' ) !== '';
            }
        );
        $tagsToRemove = array_filter(
            (array)$tagsToRemove,
            static function ( $value ) {
                return ( $value ?? '' ) !== '';
            }
        );
 
        if ( !$rc_id && !$rev_id && !$log_id ) {
            throw new BadMethodCallException( 'At least one of: RCID, revision ID, and log ID MUST be ' .
                'specified when adding or removing a tag from a change!' );
        }
 
        $dbw = $this->dbProvider->getPrimaryDatabase();
 
        // Might as well look for rcids and so on.
        if ( !$rc_id ) {
            // Info might be out of date, somewhat fractionally, on replica DB.
            // LogEntry/LogPage and WikiPage match rev/log/rc timestamps,
            // so use that relation to avoid full table scans.
            if ( $log_id ) {
                $rc_id = $dbw->newSelectQueryBuilder()
                    ->select( 'rc_id' )
                    ->from( 'logging' )
                    ->join( 'recentchanges', null, [
                        'rc_timestamp = log_timestamp',
                        'rc_logid = log_id'
                    ] )
                    ->where( [ 'log_id' => $log_id ] )
                    ->caller( __METHOD__ )
                    ->fetchField();
            } elseif ( $rev_id ) {
                $rc_id = $dbw->newSelectQueryBuilder()
                    ->select( 'rc_id' )
                    ->from( 'revision' )
                    ->join( 'recentchanges', null, [
                        'rc_this_oldid = rev_id'
                    ] )
                    ->where( [ 'rev_id' => $rev_id ] )
                    ->caller( __METHOD__ )
                    ->fetchField();
            }
        } elseif ( !$log_id && !$rev_id ) {
            // Info might be out of date, somewhat fractionally, on replica DB.
            $log_id = $dbw->newSelectQueryBuilder()
                ->select( 'rc_logid' )
                ->from( 'recentchanges' )
                ->where( [ 'rc_id' => $rc_id ] )
                ->caller( __METHOD__ )
                ->fetchField();
            $rev_id = $dbw->newSelectQueryBuilder()
                ->select( 'rc_this_oldid' )
                ->from( 'recentchanges' )
                ->where( [ 'rc_id' => $rc_id ] )
                ->caller( __METHOD__ )
                ->fetchField();
        }
 
        if ( $log_id && !$rev_id ) {
            $rev_id = $dbw->newSelectQueryBuilder()
                ->select( 'ls_value' )
                ->from( 'log_search' )
                ->where( [ 'ls_field' => 'associated_rev_id', 'ls_log_id' => $log_id ] )
                ->caller( __METHOD__ )
                ->fetchField();
        } elseif ( !$log_id && $rev_id ) {
            $log_id = $dbw->newSelectQueryBuilder()
                ->select( 'ls_log_id' )
                ->from( 'log_search' )
                ->where( [ 'ls_field' => 'associated_rev_id', 'ls_value' => (string)$rev_id ] )
                ->caller( __METHOD__ )
                ->fetchField();
        }
 
        $prevTags = $this->getTags( $dbw, $rc_id, $rev_id, $log_id );
 
        // add tags
        $tagsToAdd = array_values( array_diff( $tagsToAdd, $prevTags ) );
        $newTags = array_unique( array_merge( $prevTags, $tagsToAdd ) );
 
        // remove tags
        $tagsToRemove = array_values( array_intersect( $tagsToRemove, $newTags ) );
        $newTags = array_values( array_diff( $newTags, $tagsToRemove ) );
 
        sort( $prevTags );
        sort( $newTags );
        if ( $prevTags == $newTags ) {
            return [ [], [], $prevTags ];
        }
 
        // insert a row into change_tag for each new tag
        if ( count( $tagsToAdd ) ) {
            $changeTagMapping = [];
            foreach ( $tagsToAdd as $tag ) {
                $changeTagMapping[$tag] = $this->changeTagDefStore->acquireId( $tag );
            }
            $fname = __METHOD__;
            // T207881: update the counts at the end of the transaction
            $dbw->onTransactionPreCommitOrIdle( static function () use ( $dbw, $tagsToAdd, $fname ) {
                $dbw->newUpdateQueryBuilder()
                    ->update( self::CHANGE_TAG_DEF )
                    ->set( [ 'ctd_count = ctd_count + 1' ] )
                    ->where( [ 'ctd_name' => $tagsToAdd ] )
                    ->caller( $fname )->execute();
            }, $fname );
 
            $tagsRows = [];
            foreach ( $tagsToAdd as $tag ) {
                // Filter so we don't insert NULLs as zero accidentally.
                // Keep in mind that $rc_id === null means "I don't care/know about the
                // rc_id, just delete $tag on this revision/log entry". It doesn't
                // mean "only delete tags on this revision/log WHERE rc_id IS NULL".
                $tagsRows[] = array_filter(
                    [
                        'ct_rc_id' => $rc_id,
                        'ct_log_id' => $log_id,
                        'ct_rev_id' => $rev_id,
                        'ct_params' => $params,
                        'ct_tag_id' => $changeTagMapping[$tag] ?? null,
                    ]
                );
 
            }
 
            $dbw->newInsertQueryBuilder()
                ->insertInto( self::CHANGE_TAG )
                ->ignore()
                ->rows( $tagsRows )
                ->caller( __METHOD__ )->execute();
        }
 
        // delete from change_tag
        if ( count( $tagsToRemove ) ) {
            $fname = __METHOD__;
            foreach ( $tagsToRemove as $tag ) {
                $conds = array_filter(
                    [
                        'ct_rc_id' => $rc_id,
                        'ct_log_id' => $log_id,
                        'ct_rev_id' => $rev_id,
                        'ct_tag_id' => $this->changeTagDefStore->getId( $tag ),
                    ]
                );
                $dbw->newDeleteQueryBuilder()
                    ->deleteFrom( self::CHANGE_TAG )
                    ->where( $conds )
                    ->caller( __METHOD__ )->execute();
                if ( $dbw->affectedRows() ) {
                    // T207881: update the counts at the end of the transaction
                    $dbw->onTransactionPreCommitOrIdle( static function () use ( $dbw, $tag, $fname ) {
                        $dbw->newUpdateQueryBuilder()
                            ->update( self::CHANGE_TAG_DEF )
                            ->set( [ 'ctd_count = ctd_count - 1' ] )
                            ->where( [ 'ctd_name' => $tag ] )
                            ->caller( $fname )->execute();
 
                        $dbw->newDeleteQueryBuilder()
                            ->deleteFrom( self::CHANGE_TAG_DEF )
                            ->where( [ 'ctd_name' => $tag, 'ctd_count' => 0, 'ctd_user_defined' => 0 ] )
                            ->caller( $fname )->execute();
                    }, $fname );
                }
            }
        }
 
        $userObj = $user ? $this->userFactory->newFromUserIdentity( $user ) : null;
        $this->hookRunner->onChangeTagsAfterUpdateTags(
            $tagsToAdd, $tagsToRemove, $prevTags, $rc_id, $rev_id, $log_id, $params, $rc, $userObj );
 
        return [ $tagsToAdd, $tagsToRemove, $prevTags ];
    }
 
    public function addTags( $tags, $rc_id = null, $rev_id = null,
        $log_id = null, $params = null, RecentChange $rc = null
    ) {
        $result = $this->updateTags( $tags, null, $rc_id, $rev_id, $log_id, $params, $rc );
        return (bool)$result[0];
    }
 
    public function listSoftwareActivatedTags() {
        // core active tags
        $tags = $this->getSoftwareTags();
        if ( !$this->hookContainer->isRegistered( 'ChangeTagsListActive' ) ) {
            return $tags;
        }
        $hookRunner = $this->hookRunner;
        $dbProvider = $this->dbProvider;
 
        return $this->wanCache->getWithSetCallback(
            $this->wanCache->makeKey( 'active-tags' ),
            WANObjectCache::TTL_MINUTE * 5,
            static function ( $oldValue, &$ttl, array &$setOpts ) use ( $tags, $hookRunner, $dbProvider ) {
                $setOpts += Database::getCacheSetOptions( $dbProvider->getReplicaDatabase() );
 
                // Ask extensions which tags they consider active
                $hookRunner->onChangeTagsListActive( $tags );
                return $tags;
            },
            [
                'checkKeys' => [ $this->wanCache->makeKey( 'active-tags' ) ],
                'lockTSE' => WANObjectCache::TTL_MINUTE * 5,
                'pcTTL' => WANObjectCache::TTL_PROC_LONG
            ]
        );
    }
 
    public function modifyDisplayQuery( &$tables, &$fields, &$conds,
        &$join_conds, &$options, $filter_tag = '', bool $exclude = false
    ) {
        $useTagFilter = $this->options->get( MainConfigNames::UseTagFilter );
 
        // Normalize to arrays
        $tables = (array)$tables;
        $fields = (array)$fields;
        $conds = (array)$conds;
        $options = (array)$options;
 
        $fields['ts_tags'] = $this->makeTagSummarySubquery( $tables );
        // We use an alias and qualify the conditions in case there are
        // multiple joins to this table.
        // In particular for compatibility with the RC filters that extension Translate does.
 
        // Figure out which ID field to use
        if ( in_array( 'recentchanges', $tables ) ) {
            $join_cond = self::DISPLAY_TABLE_ALIAS . '.ct_rc_id=rc_id';
        } elseif ( in_array( 'logging', $tables ) ) {
            $join_cond = self::DISPLAY_TABLE_ALIAS . '.ct_log_id=log_id';
        } elseif ( in_array( 'revision', $tables ) ) {
            $join_cond = self::DISPLAY_TABLE_ALIAS . '.ct_rev_id=rev_id';
        } elseif ( in_array( 'archive', $tables ) ) {
            $join_cond = self::DISPLAY_TABLE_ALIAS . '.ct_rev_id=ar_rev_id';
        } else {
            throw new InvalidArgumentException( 'Unable to determine appropriate JOIN condition for tagging.' );
        }
 
        if ( !$useTagFilter ) {
            return;
        }
 
        if ( !is_array( $filter_tag ) ) {
            // some callers provide false or null
            $filter_tag = (string)$filter_tag;
        }
 
        if ( $filter_tag !== [] && $filter_tag !== '' ) {
            // Somebody wants to filter on a tag.
            // Add an INNER JOIN on change_tag
            $filterTagIds = [];
            foreach ( (array)$filter_tag as $filterTagName ) {
                try {
                    $filterTagIds[] = $this->changeTagDefStore->getId( $filterTagName );
                } catch ( NameTableAccessException $exception ) {
                }
            }
 
            if ( $exclude ) {
                if ( $filterTagIds !== [] ) {
                    $tables[self::DISPLAY_TABLE_ALIAS] = self::CHANGE_TAG;
                    $join_conds[self::DISPLAY_TABLE_ALIAS] = [
                        'LEFT JOIN',
                        [ $join_cond, self::DISPLAY_TABLE_ALIAS . '.ct_tag_id' => $filterTagIds ]
                    ];
                    $conds[self::DISPLAY_TABLE_ALIAS . '.ct_tag_id'] = null;
                }
            } else {
                $tables[self::DISPLAY_TABLE_ALIAS] = self::CHANGE_TAG;
                $join_conds[self::DISPLAY_TABLE_ALIAS] = [ 'JOIN', $join_cond ];
                if ( $filterTagIds !== [] ) {
                    $conds[self::DISPLAY_TABLE_ALIAS . '.ct_tag_id'] = $filterTagIds;
                } else {
                    // all tags were invalid, return nothing
                    $conds[] = '0=1';
                }
 
                if (
                    is_array( $filter_tag ) && count( $filter_tag ) > 1 &&
                    !in_array( 'DISTINCT', $options )
                ) {
                    $options[] = 'DISTINCT';
                }
            }
        }
    }
}