CommentStore.php

Go to the documentation of this file.

<?php
use MediaWiki\MediaWikiServices;
use Wikimedia\Rdbms\IDatabase;
 
class CommentStore {
 
    const COMMENT_CHARACTER_LIMIT = 500;
 
    const MAX_COMMENT_LENGTH = 65535;
 
    const MAX_DATA_LENGTH = 65535;
 
    protected static $tempTables = [
        'rev_comment' => [
            'table' => 'revision_comment_temp',
            'pk' => 'revcomment_rev',
            'field' => 'revcomment_comment_id',
            'joinPK' => 'rev_id',
        ],
        'img_description' => [
            'table' => 'image_comment_temp',
            'pk' => 'imgcomment_name',
            'field' => 'imgcomment_description_id',
            'joinPK' => 'img_name',
        ],
    ];
 
    protected static $formerTempTables = [];
 
    protected $key = null;
 
    protected $stage;
 
    protected $joinCache = [];
 
    protected $lang;
 
    public function __construct( Language $lang, $migrationStage ) {
        $this->stage = $migrationStage;
        $this->lang = $lang;
    }
 
    public static function newKey( $key ) {
        global $wgCommentTableSchemaMigrationStage, $wgContLang;
        // TODO uncomment once not used in extensions
        // wfDeprecated( __METHOD__, '1.31' );
        $store = new CommentStore( $wgContLang, $wgCommentTableSchemaMigrationStage );
        $store->key = $key;
        return $store;
    }
 
    public static function getStore() {
        return MediaWikiServices::getInstance()->getCommentStore();
    }
 
    private function getKey( $methodKey = null ) {
        $key = $this->key !== null ? $this->key : $methodKey;
        if ( $key === null ) {
            // @codeCoverageIgnoreStart
            throw new InvalidArgumentException( '$key should not be null' );
            // @codeCoverageIgnoreEnd
        }
        return $key;
    }
 
    public function getFields( $key = null ) {
        $key = $this->getKey( $key );
        $fields = [];
        if ( $this->stage === MIGRATION_OLD ) {
            $fields["{$key}_text"] = $key;
            $fields["{$key}_data"] = 'NULL';
            $fields["{$key}_cid"] = 'NULL';
        } else {
            if ( $this->stage < MIGRATION_NEW ) {
                $fields["{$key}_old"] = $key;
            }
            if ( isset( self::$tempTables[$key] ) ) {
                $fields["{$key}_pk"] = self::$tempTables[$key]['joinPK'];
            } else {
                $fields["{$key}_id"] = "{$key}_id";
            }
        }
        return $fields;
    }
 
    public function getJoin( $key = null ) {
        $key = $this->getKey( $key );
        if ( !array_key_exists( $key, $this->joinCache ) ) {
            $tables = [];
            $fields = [];
            $joins = [];
 
            if ( $this->stage === MIGRATION_OLD ) {
                $fields["{$key}_text"] = $key;
                $fields["{$key}_data"] = 'NULL';
                $fields["{$key}_cid"] = 'NULL';
            } else {
                $join = $this->stage === MIGRATION_NEW ? 'JOIN' : 'LEFT JOIN';
 
                if ( isset( self::$tempTables[$key] ) ) {
                    $t = self::$tempTables[$key];
                    $alias = "temp_$key";
                    $tables[$alias] = $t['table'];
                    $joins[$alias] = [ $join, "{$alias}.{$t['pk']} = {$t['joinPK']}" ];
                    $joinField = "{$alias}.{$t['field']}";
                } else {
                    $joinField = "{$key}_id";
                }
 
                $alias = "comment_$key";
                $tables[$alias] = 'comment';
                $joins[$alias] = [ $join, "{$alias}.comment_id = {$joinField}" ];
 
                if ( $this->stage === MIGRATION_NEW ) {
                    $fields["{$key}_text"] = "{$alias}.comment_text";
                } else {
                    $fields["{$key}_text"] = "COALESCE( {$alias}.comment_text, $key )";
                }
                $fields["{$key}_data"] = "{$alias}.comment_data";
                $fields["{$key}_cid"] = "{$alias}.comment_id";
            }
 
            $this->joinCache[$key] = [
                'tables' => $tables,
                'fields' => $fields,
                'joins' => $joins,
            ];
        }
 
        return $this->joinCache[$key];
    }
 
    private function getCommentInternal( IDatabase $db = null, $key, $row, $fallback = false ) {
        $row = (array)$row;
        if ( array_key_exists( "{$key}_text", $row ) && array_key_exists( "{$key}_data", $row ) ) {
            $cid = isset( $row["{$key}_cid"] ) ? $row["{$key}_cid"] : null;
            $text = $row["{$key}_text"];
            $data = $row["{$key}_data"];
        } elseif ( $this->stage === MIGRATION_OLD ) {
            $cid = null;
            if ( $fallback && isset( $row[$key] ) ) {
                wfLogWarning( "Using deprecated fallback handling for comment $key" );
                $text = $row[$key];
            } else {
                wfLogWarning( "Missing {$key}_text and {$key}_data fields in row with MIGRATION_OLD" );
                $text = '';
            }
            $data = null;
        } else {
            if ( isset( self::$tempTables[$key] ) ) {
                if ( array_key_exists( "{$key}_pk", $row ) ) {
                    if ( !$db ) {
                        throw new InvalidArgumentException(
                            "\$row does not contain fields needed for comment $key and getComment(), but "
                            . "does have fields for getCommentLegacy()"
                        );
                    }
                    $t = self::$tempTables[$key];
                    $id = $row["{$key}_pk"];
                    $row2 = $db->selectRow(
                        [ $t['table'], 'comment' ],
                        [ 'comment_id', 'comment_text', 'comment_data' ],
                        [ $t['pk'] => $id ],
                        __METHOD__,
                        [],
                        [ 'comment' => [ 'JOIN', [ "comment_id = {$t['field']}" ] ] ]
                    );
                } elseif ( $fallback && isset( $row[$key] ) ) {
                    wfLogWarning( "Using deprecated fallback handling for comment $key" );
                    $row2 = (object)[ 'comment_text' => $row[$key], 'comment_data' => null ];
                } else {
                    throw new InvalidArgumentException( "\$row does not contain fields needed for comment $key" );
                }
            } else {
                if ( array_key_exists( "{$key}_id", $row ) ) {
                    if ( !$db ) {
                        throw new InvalidArgumentException(
                            "\$row does not contain fields needed for comment $key and getComment(), but "
                            . "does have fields for getCommentLegacy()"
                        );
                    }
                    $id = $row["{$key}_id"];
                    $row2 = $db->selectRow(
                        'comment',
                        [ 'comment_id', 'comment_text', 'comment_data' ],
                        [ 'comment_id' => $id ],
                        __METHOD__
                    );
                } elseif ( $fallback && isset( $row[$key] ) ) {
                    wfLogWarning( "Using deprecated fallback handling for comment $key" );
                    $row2 = (object)[ 'comment_text' => $row[$key], 'comment_data' => null ];
                } else {
                    throw new InvalidArgumentException( "\$row does not contain fields needed for comment $key" );
                }
            }
 
            if ( $row2 ) {
                $cid = $row2->comment_id;
                $text = $row2->comment_text;
                $data = $row2->comment_data;
            } elseif ( $this->stage < MIGRATION_NEW && array_key_exists( "{$key}_old", $row ) ) {
                $cid = null;
                $text = $row["{$key}_old"];
                $data = null;
            } else {
                // @codeCoverageIgnoreStart
                wfLogWarning( "Missing comment row for $key, id=$id" );
                $cid = null;
                $text = '';
                $data = null;
                // @codeCoverageIgnoreEnd
            }
        }
 
        $msg = null;
        if ( $data !== null ) {
            $data = FormatJson::decode( $data );
            if ( !is_object( $data ) ) {
                // @codeCoverageIgnoreStart
                wfLogWarning( "Invalid JSON object in comment: $data" );
                $data = null;
                // @codeCoverageIgnoreEnd
            } else {
                $data = (array)$data;
                if ( isset( $data['_message'] ) ) {
                    $msg = self::decodeMessage( $data['_message'] )
                        ->setInterfaceMessageFlag( true );
                }
                if ( !empty( $data['_null'] ) ) {
                    $data = null;
                } else {
                    foreach ( $data as $k => $v ) {
                        if ( substr( $k, 0, 1 ) === '_' ) {
                            unset( $data[$k] );
                        }
                    }
                }
            }
        }
 
        return new CommentStoreComment( $cid, $text, $msg, $data );
    }
 
    public function getComment( $key, $row = null, $fallback = false ) {
        // Compat for method sig change in 1.31 (introduction of $key)
        if ( $this->key !== null ) {
            $fallback = $row;
            $row = $key;
            $key = $this->getKey();
        }
        if ( $row === null ) {
            // @codeCoverageIgnoreStart
            throw new InvalidArgumentException( '$row must not be null' );
            // @codeCoverageIgnoreEnd
        }
        return $this->getCommentInternal( null, $key, $row, $fallback );
    }
 
    public function getCommentLegacy( IDatabase $db, $key, $row = null, $fallback = false ) {
        // Compat for method sig change in 1.31 (introduction of $key)
        if ( $this->key !== null ) {
            $fallback = $row;
            $row = $key;
            $key = $this->getKey();
        }
        if ( $row === null ) {
            // @codeCoverageIgnoreStart
            throw new InvalidArgumentException( '$row must not be null' );
            // @codeCoverageIgnoreEnd
        }
        return $this->getCommentInternal( $db, $key, $row, $fallback );
    }
 
    public function createComment( IDatabase $dbw, $comment, array $data = null ) {
        $comment = CommentStoreComment::newUnsavedComment( $comment, $data );
 
        # Truncate comment in a Unicode-sensitive manner
        $comment->text = $this->lang->truncate( $comment->text, self::MAX_COMMENT_LENGTH );
        if ( mb_strlen( $comment->text, 'UTF-8' ) > self::COMMENT_CHARACTER_LIMIT ) {
            $ellipsis = wfMessage( 'ellipsis' )->inLanguage( $this->lang )->escaped();
            if ( mb_strlen( $ellipsis ) >= self::COMMENT_CHARACTER_LIMIT ) {
                // WTF?
                $ellipsis = '...';
            }
            $maxLength = self::COMMENT_CHARACTER_LIMIT - mb_strlen( $ellipsis, 'UTF-8' );
            $comment->text = mb_substr( $comment->text, 0, $maxLength, 'UTF-8' ) . $ellipsis;
        }
 
        if ( $this->stage > MIGRATION_OLD && !$comment->id ) {
            $dbData = $comment->data;
            if ( !$comment->message instanceof RawMessage ) {
                if ( $dbData === null ) {
                    $dbData = [ '_null' => true ];
                }
                $dbData['_message'] = self::encodeMessage( $comment->message );
            }
            if ( $dbData !== null ) {
                $dbData = FormatJson::encode( (object)$dbData, false, FormatJson::ALL_OK );
                $len = strlen( $dbData );
                if ( $len > self::MAX_DATA_LENGTH ) {
                    $max = self::MAX_DATA_LENGTH;
                    throw new OverflowException( "Comment data is too long ($len bytes, maximum is $max)" );
                }
            }
 
            $hash = self::hash( $comment->text, $dbData );
            $comment->id = $dbw->selectField(
                'comment',
                'comment_id',
                [
                    'comment_hash' => $hash,
                    'comment_text' => $comment->text,
                    'comment_data' => $dbData,
                ],
                __METHOD__
            );
            if ( !$comment->id ) {
                $dbw->insert(
                    'comment',
                    [
                        'comment_hash' => $hash,
                        'comment_text' => $comment->text,
                        'comment_data' => $dbData,
                    ],
                    __METHOD__
                );
                $comment->id = $dbw->insertId();
            }
        }
 
        return $comment;
    }
 
    private function insertInternal( IDatabase $dbw, $key, $comment, $data ) {
        $fields = [];
        $callback = null;
 
        $comment = $this->createComment( $dbw, $comment, $data );
 
        if ( $this->stage <= MIGRATION_WRITE_BOTH ) {
            $fields[$key] = $this->lang->truncate( $comment->text, 255 );
        }
 
        if ( $this->stage >= MIGRATION_WRITE_BOTH ) {
            if ( isset( self::$tempTables[$key] ) ) {
                $t = self::$tempTables[$key];
                $func = __METHOD__;
                $commentId = $comment->id;
                $callback = function ( $id ) use ( $dbw, $commentId, $t, $func ) {
                    $dbw->insert(
                        $t['table'],
                        [
                            $t['pk'] => $id,
                            $t['field'] => $commentId,
                        ],
                        $func
                    );
                };
            } else {
                $fields["{$key}_id"] = $comment->id;
            }
        }
 
        return [ $fields, $callback ];
    }
 
    public function insert( IDatabase $dbw, $key, $comment = null, $data = null ) {
        // Compat for method sig change in 1.31 (introduction of $key)
        if ( $this->key !== null ) {
            $data = $comment;
            $comment = $key;
            $key = $this->key;
        }
        if ( $comment === null ) {
            // @codeCoverageIgnoreStart
            throw new InvalidArgumentException( '$comment can not be null' );
            // @codeCoverageIgnoreEnd
        }
 
        if ( isset( self::$tempTables[$key] ) ) {
            throw new InvalidArgumentException( "Must use insertWithTempTable() for $key" );
        }
 
        list( $fields ) = $this->insertInternal( $dbw, $key, $comment, $data );
        return $fields;
    }
 
    public function insertWithTempTable( IDatabase $dbw, $key, $comment = null, $data = null ) {
        // Compat for method sig change in 1.31 (introduction of $key)
        if ( $this->key !== null ) {
            $data = $comment;
            $comment = $key;
            $key = $this->getKey();
        }
        if ( $comment === null ) {
            // @codeCoverageIgnoreStart
            throw new InvalidArgumentException( '$comment can not be null' );
            // @codeCoverageIgnoreEnd
        }
 
        if ( isset( self::$formerTempTables[$key] ) ) {
            wfDeprecated( __METHOD__ . " for $key", self::$formerTempTables[$key] );
        } elseif ( !isset( self::$tempTables[$key] ) ) {
            throw new InvalidArgumentException( "Must use insert() for $key" );
        }
 
        list( $fields, $callback ) = $this->insertInternal( $dbw, $key, $comment, $data );
        if ( !$callback ) {
            $callback = function () {
                // Do nothing.
            };
        }
        return [ $fields, $callback ];
    }
 
    protected static function encodeMessage( Message $msg ) {
        $key = count( $msg->getKeysToTry() ) > 1 ? $msg->getKeysToTry() : $msg->getKey();
        $params = $msg->getParams();
        foreach ( $params as &$param ) {
            if ( $param instanceof Message ) {
                $param = [
                    'message' => self::encodeMessage( $param )
                ];
            }
        }
        array_unshift( $params, $key );
        return $params;
    }
 
    protected static function decodeMessage( $data ) {
        $key = array_shift( $data );
        foreach ( $data as &$param ) {
            if ( is_object( $param ) ) {
                $param = (array)$param;
            }
            if ( is_array( $param ) && count( $param ) === 1 && isset( $param['message'] ) ) {
                $param = self::decodeMessage( $param['message'] );
            }
        }
        return new Message( $key, $data );
    }
 
    public static function hash( $text, $data ) {
        $hash = crc32( $text ) ^ crc32( (string)$data );
 
        // 64-bit PHP returns an unsigned CRC, change it to signed for
        // insertion into the database.
        if ( $hash >= 0x80000000 ) {
            $hash |= -1 << 32;
        }
 
        return $hash;
    }
 
}