ApiQueryBase.php

Go to the documentation of this file.

<?php
abstract class ApiQueryBase extends ApiBase {

    private $mQueryModule, $mDb, $tables, $where, $fields, $options, $join_conds;

    public function __construct( ApiBase $query, $moduleName, $paramPrefix = '' ) {
        parent::__construct( $query->getMain(), $moduleName, $paramPrefix );
        $this->mQueryModule = $query;
        $this->mDb = null;
        $this->resetQueryParams();
    }

    public function getCacheMode( $params ) {
        return 'private';
    }

    protected function resetQueryParams() {
        $this->tables = array();
        $this->where = array();
        $this->fields = array();
        $this->options = array();
        $this->join_conds = array();
    }

    protected function addTables( $tables, $alias = null ) {
        if ( is_array( $tables ) ) {
            if ( !is_null( $alias ) ) {
                ApiBase::dieDebug( __METHOD__, 'Multiple table aliases not supported' );
            }
            $this->tables = array_merge( $this->tables, $tables );
        } else {
            if ( !is_null( $alias ) ) {
                $this->tables[$alias] = $tables;
            } else {
                $this->tables[] = $tables;
            }
        }
    }

    protected function addJoinConds( $join_conds ) {
        if ( !is_array( $join_conds ) ) {
            ApiBase::dieDebug( __METHOD__, 'Join conditions have to be arrays' );
        }
        $this->join_conds = array_merge( $this->join_conds, $join_conds );
    }

    protected function addFields( $value ) {
        if ( is_array( $value ) ) {
            $this->fields = array_merge( $this->fields, $value );
        } else {
            $this->fields[] = $value;
        }
    }

    protected function addFieldsIf( $value, $condition ) {
        if ( $condition ) {
            $this->addFields( $value );

            return true;
        }

        return false;
    }

    protected function addWhere( $value ) {
        if ( is_array( $value ) ) {
            // Sanity check: don't insert empty arrays,
            // Database::makeList() chokes on them
            if ( count( $value ) ) {
                $this->where = array_merge( $this->where, $value );
            }
        } else {
            $this->where[] = $value;
        }
    }

    protected function addWhereIf( $value, $condition ) {
        if ( $condition ) {
            $this->addWhere( $value );

            return true;
        }

        return false;
    }

    protected function addWhereFld( $field, $value ) {
        // Use count() to its full documented capabilities to simultaneously
        // test for null, empty array or empty countable object
        if ( count( $value ) ) {
            $this->where[$field] = $value;
        }
    }

    protected function addWhereRange( $field, $dir, $start, $end, $sort = true ) {
        $isDirNewer = ( $dir === 'newer' );
        $after = ( $isDirNewer ? '>=' : '<=' );
        $before = ( $isDirNewer ? '<=' : '>=' );
        $db = $this->getDB();

        if ( !is_null( $start ) ) {
            $this->addWhere( $field . $after . $db->addQuotes( $start ) );
        }

        if ( !is_null( $end ) ) {
            $this->addWhere( $field . $before . $db->addQuotes( $end ) );
        }

        if ( $sort ) {
            $order = $field . ( $isDirNewer ? '' : ' DESC' );
            // Append ORDER BY
            $optionOrderBy = isset( $this->options['ORDER BY'] )
                ? (array)$this->options['ORDER BY']
                : array();
            $optionOrderBy[] = $order;
            $this->addOption( 'ORDER BY', $optionOrderBy );
        }
    }

    protected function addTimestampWhereRange( $field, $dir, $start, $end, $sort = true ) {
        $db = $this->getDb();
        $this->addWhereRange( $field, $dir,
            $db->timestampOrNull( $start ), $db->timestampOrNull( $end ), $sort );
    }

    protected function addOption( $name, $value = null ) {
        if ( is_null( $value ) ) {
            $this->options[] = $name;
        } else {
            $this->options[$name] = $value;
        }
    }

    protected function select( $method, $extraQuery = array() ) {

        $tables = array_merge(
            $this->tables,
            isset( $extraQuery['tables'] ) ? (array)$extraQuery['tables'] : array()
        );
        $fields = array_merge(
            $this->fields,
            isset( $extraQuery['fields'] ) ? (array)$extraQuery['fields'] : array()
        );
        $where = array_merge(
            $this->where,
            isset( $extraQuery['where'] ) ? (array)$extraQuery['where'] : array()
        );
        $options = array_merge(
            $this->options,
            isset( $extraQuery['options'] ) ? (array)$extraQuery['options'] : array()
        );
        $join_conds = array_merge(
            $this->join_conds,
            isset( $extraQuery['join_conds'] ) ? (array)$extraQuery['join_conds'] : array()
        );

        // getDB has its own profileDBIn/Out calls
        $db = $this->getDB();

        $this->profileDBIn();
        $res = $db->select( $tables, $fields, $where, $method, $options, $join_conds );
        $this->profileDBOut();

        return $res;
    }

    protected function checkRowCount() {
        $db = $this->getDB();
        $this->profileDBIn();
        $rowcount = $db->estimateRowCount(
            $this->tables,
            $this->fields,
            $this->where,
            __METHOD__,
            $this->options
        );
        $this->profileDBOut();

        global $wgAPIMaxDBRows;
        if ( $rowcount > $wgAPIMaxDBRows ) {
            return false;
        }

        return true;
    }

    public static function addTitleInfo( &$arr, $title, $prefix = '' ) {
        $arr[$prefix . 'ns'] = intval( $title->getNamespace() );
        $arr[$prefix . 'title'] = $title->getPrefixedText();
    }

    public function requestExtraData( $pageSet ) {
    }

    public function getQuery() {
        return $this->mQueryModule;
    }

    protected function addPageSubItems( $pageId, $data ) {
        $result = $this->getResult();
        $result->setIndexedTagName( $data, $this->getModulePrefix() );

        return $result->addValue( array( 'query', 'pages', intval( $pageId ) ),
            $this->getModuleName(),
            $data );
    }

    protected function addPageSubItem( $pageId, $item, $elemname = null ) {
        if ( is_null( $elemname ) ) {
            $elemname = $this->getModulePrefix();
        }
        $result = $this->getResult();
        $fit = $result->addValue( array( 'query', 'pages', $pageId,
            $this->getModuleName() ), null, $item );
        if ( !$fit ) {
            return false;
        }
        $result->setIndexedTagName_internal( array( 'query', 'pages', $pageId,
            $this->getModuleName() ), $elemname );

        return true;
    }

    protected function setContinueEnumParameter( $paramName, $paramValue ) {
        $paramName = $this->encodeParamName( $paramName );
        $msg = array( $paramName => $paramValue );
        $result = $this->getResult();
        $result->disableSizeCheck();
        $result->addValue( 'query-continue', $this->getModuleName(), $msg, ApiResult::ADD_ON_TOP );
        $result->enableSizeCheck();
    }

    protected function getDB() {
        if ( is_null( $this->mDb ) ) {
            $this->mDb = $this->getQuery()->getDB();
        }

        return $this->mDb;
    }

    public function selectNamedDB( $name, $db, $groups ) {
        $this->mDb = $this->getQuery()->getNamedDB( $name, $db, $groups );
    }

    protected function getPageSet() {
        return $this->getQuery()->getPageSet();
    }

    public function titleToKey( $title ) {
        // Don't throw an error if we got an empty string
        if ( trim( $title ) == '' ) {
            return '';
        }
        $t = Title::newFromText( $title );
        if ( !$t ) {
            $this->dieUsageMsg( array( 'invalidtitle', $title ) );
        }

        return $t->getPrefixedDBkey();
    }

    public function keyToTitle( $key ) {
        // Don't throw an error if we got an empty string
        if ( trim( $key ) == '' ) {
            return '';
        }
        $t = Title::newFromDBkey( $key );
        // This really shouldn't happen but we gotta check anyway
        if ( !$t ) {
            $this->dieUsageMsg( array( 'invalidtitle', $key ) );
        }

        return $t->getPrefixedText();
    }

    public function titlePartToKey( $titlePart, $defaultNamespace = NS_MAIN ) {
        $t = Title::makeTitleSafe( $defaultNamespace, $titlePart . 'x' );
        if ( !$t ) {
            $this->dieUsageMsg( array( 'invalidtitle', $titlePart ) );
        }
        if ( $defaultNamespace != $t->getNamespace() || $t->isExternal() ) {
            // This can happen in two cases. First, if you call titlePartToKey with a title part
            // that looks like a namespace, but with $defaultNamespace = NS_MAIN. It would be very
            // difficult to handle such a case. Such cases cannot exist and are therefore treated
            // as invalid user input. The second case is when somebody specifies a title interwiki
            // prefix.
            $this->dieUsageMsg( array( 'invalidtitle', $titlePart ) );
        }

        return substr( $t->getDbKey(), 0, -1 );
    }

    public function keyPartToTitle( $keyPart ) {
        return substr( $this->keyToTitle( $keyPart . 'x' ), 0, -1 );
    }

    public function getDirectionDescription( $p = '', $extraDirText = '' ) {
        return array(
            "In which direction to enumerate{$extraDirText}",
            " newer          - List oldest first. Note: {$p}start has to be before {$p}end.",
            " older          - List newest first (default). Note: {$p}start has to be later than {$p}end.",
        );
    }

    public function prepareUrlQuerySearchString( $query = null, $protocol = null ) {
        $db = $this->getDb();
        if ( !is_null( $query ) || $query != '' ) {
            if ( is_null( $protocol ) ) {
                $protocol = 'http://';
            }

            $likeQuery = LinkFilter::makeLikeArray( $query, $protocol );
            if ( !$likeQuery ) {
                $this->dieUsage( 'Invalid query', 'bad_query' );
            }

            $likeQuery = LinkFilter::keepOneWildcard( $likeQuery );

            return 'el_index ' . $db->buildLike( $likeQuery );
        } elseif ( !is_null( $protocol ) ) {
            return 'el_index ' . $db->buildLike( "$protocol", $db->anyString() );
        }

        return null;
    }

    public function showHiddenUsersAddBlockInfo( $showBlockInfo ) {
        $this->addTables( 'ipblocks' );
        $this->addJoinConds( array(
            'ipblocks' => array( 'LEFT JOIN', 'ipb_user=user_id' ),
        ) );

        $this->addFields( 'ipb_deleted' );

        if ( $showBlockInfo ) {
            $this->addFields( array( 'ipb_id', 'ipb_by', 'ipb_by_text', 'ipb_reason', 'ipb_expiry' ) );
        }

        // Don't show hidden names
        if ( !$this->getUser()->isAllowed( 'hideuser' ) ) {
            $this->addWhere( 'ipb_deleted = 0 OR ipb_deleted IS NULL' );
        }
    }

    public function validateSha1Hash( $hash ) {
        return preg_match( '/^[a-f0-9]{40}$/', $hash );
    }

    public function validateSha1Base36Hash( $hash ) {
        return preg_match( '/^[a-z0-9]{31}$/', $hash );
    }

    public function getPossibleErrors() {
        $errors = parent::getPossibleErrors();
        $errors = array_merge( $errors, array(
            array( 'invalidtitle', 'title' ),
            array( 'invalidtitle', 'key' ),
        ) );

        return $errors;
    }

    public function userCanSeeRevDel() {
        return $this->getUser()->isAllowedAny( 'deletedhistory', 'deletedtext', 'suppressrevision' );
    }
}

abstract class ApiQueryGeneratorBase extends ApiQueryBase {

    private $mGeneratorPageSet = null;

    public function setGeneratorMode( ApiPageSet $generatorPageSet ) {
        if ( $generatorPageSet === null ) {
            ApiBase::dieDebug( __METHOD__, 'Required parameter missing - $generatorPageSet' );
        }
        $this->mGeneratorPageSet = $generatorPageSet;
    }

    protected function getPageSet() {
        if ( $this->mGeneratorPageSet !== null ) {
            return $this->mGeneratorPageSet;
        }

        return parent::getPageSet();
    }

    public function encodeParamName( $paramName ) {
        if ( $this->mGeneratorPageSet !== null ) {
            return 'g' . parent::encodeParamName( $paramName );
        } else {
            return parent::encodeParamName( $paramName );
        }
    }

    protected function setContinueEnumParameter( $paramName, $paramValue ) {
        // If this is a generator and query->setGeneratorContinue() returns false, treat as before
        if ( $this->mGeneratorPageSet === null
            || !$this->getQuery()->setGeneratorContinue( $this, $paramName, $paramValue )
        ) {
            parent::setContinueEnumParameter( $paramName, $paramValue );
        }
    }

    abstract public function executeGenerator( $resultPageSet );
}