userDupes.inc

Go to the documentation of this file.

<?php
class UserDupes {
        private $db;
        private $reassigned;
        private $trimmed;
        private $failed;
        private $outputCallback;

        function __construct( &$database, $outputCallback ) {
                $this->db = $database;
                $this->outputCallback = $outputCallback;
        }

        private function out( $str ) {
                call_user_func( $this->outputCallback, $str );
        }

        function hasUniqueIndex() {
                $info = $this->db->indexInfo( 'user', 'user_name', __METHOD__ );
                if ( !$info ) {
                        $this->out( "WARNING: doesn't seem to have user_name index at all!\n" );
                        return false;
                }

                # Confusingly, 'Non_unique' is 0 for *unique* indexes,
                # and 1 for *non-unique* indexes. Pass the crack, MySQL,
                # it's obviously some good stuff!
                return ( $info[0]->Non_unique == 0 );
        }

        function clearDupes() {
                return $this->checkDupes( true );
        }

        function checkDupes( $doDelete = false ) {
                if ( $this->hasUniqueIndex() ) {
                        echo wfWikiID() . " already has a unique index on its user table.\n";
                        return true;
                }

                $this->lock();

                $this->out( "Checking for duplicate accounts...\n" );
                $dupes = $this->getDupes();
                $count = count( $dupes );

                $this->out( "Found $count accounts with duplicate records on " . wfWikiID() . ".\n" );
                $this->trimmed    = 0;
                $this->reassigned = 0;
                $this->failed     = 0;
                foreach ( $dupes as $name ) {
                        $this->examine( $name, $doDelete );
                }

                $this->unlock();

                $this->out( "\n" );

                if ( $this->reassigned > 0 ) {
                        if ( $doDelete ) {
                                $this->out( "$this->reassigned duplicate accounts had edits reassigned to a canonical record id.\n" );
                        } else {
                                $this->out( "$this->reassigned duplicate accounts need to have edits reassigned.\n" );
                        }
                }

                if ( $this->trimmed > 0 ) {
                        if ( $doDelete ) {
                                $this->out( "$this->trimmed duplicate user records were deleted from " . wfWikiID() . ".\n" );
                        } else {
                                $this->out( "$this->trimmed duplicate user accounts were found on " . wfWikiID() . " which can be removed safely.\n" );
                        }
                }

                if ( $this->failed > 0 ) {
                        $this->out( "Something terribly awry; $this->failed duplicate accounts were not removed.\n" );
                        return false;
                }

                if ( $this->trimmed == 0 || $doDelete ) {
                        $this->out( "It is now safe to apply the unique index on user_name.\n" );
                        return true;
                } else {
                        $this->out( "Run this script again with the --fix option to automatically delete them.\n" );
                        return false;
                }
        }

        function lock() {
                if ( $this->newSchema() ) {
                        $set = array( 'user', 'revision' );
                } else {
                        $set = array( 'user', 'cur', 'old' );
                }
                $names = array_map( array( $this, 'lockTable' ), $set );
                $tables = implode( ',', $names );

                $this->db->query( "LOCK TABLES $tables", __METHOD__ );
        }

        function lockTable( $table ) {
                return $this->db->tableName( $table ) . ' WRITE';
        }

        function newSchema() {
                return MWInit::classExists( 'Revision' );
        }

        function unlock() {
                $this->db->query( "UNLOCK TABLES", __METHOD__ );
        }

        function getDupes() {
                $user = $this->db->tableName( 'user' );
                $result = $this->db->query(
                         "SELECT user_name,COUNT(*) AS n
                                FROM $user
                        GROUP BY user_name
                          HAVING n > 1", __METHOD__ );

                $list = array();
                foreach ( $result as $row ) {
                        $list[] = $row->user_name;
                }
                return $list;
        }

        function examine( $name, $doDelete ) {
                $result = $this->db->select( 'user',
                        array( 'user_id' ),
                        array( 'user_name' => $name ),
                        __METHOD__ );

                $firstRow = $this->db->fetchObject( $result );
                $firstId  = $firstRow->user_id;
                $this->out( "Record that will be used for '$name' is user_id=$firstId\n" );

                foreach ( $result as $row ) {
                        $dupeId = $row->user_id;
                        $this->out( "... dupe id $dupeId: " );
                        $edits = $this->editCount( $dupeId );
                        if ( $edits > 0 ) {
                                $this->reassigned++;
                                $this->out( "has $edits edits! " );
                                if ( $doDelete ) {
                                        $this->reassignEdits( $dupeId, $firstId );
                                        $newEdits = $this->editCount( $dupeId );
                                        if ( $newEdits == 0 ) {
                                                $this->out( "confirmed cleaned. " );
                                        } else {
                                                $this->failed++;
                                                $this->out( "WARNING! $newEdits remaining edits for $dupeId; NOT deleting user.\n" );
                                                continue;
                                        }
                                } else {
                                        $this->out( "(will need to reassign edits on fix)" );
                                }
                        } else {
                                $this->out( "ok, no edits. " );
                        }
                        $this->trimmed++;
                        if ( $doDelete ) {
                                $this->trimAccount( $dupeId );
                        }
                        $this->out( "\n" );
                }
        }

        function editCount( $userid ) {
                if ( $this->newSchema() ) {
                        return $this->editCountOn( 'revision', 'rev_user', $userid );
                } else {
                        return $this->editCountOn( 'cur', 'cur_user', $userid ) +
                                $this->editCountOn( 'old', 'old_user', $userid );
                }
        }

        function editCountOn( $table, $field, $userid ) {
                return intval( $this->db->selectField(
                        $table,
                        'COUNT(*)',
                        array( $field => $userid ),
                        __METHOD__ ) );
        }

        function reassignEdits( $from, $to ) {
                $set = $this->newSchema()
                        ? array( 'revision' => 'rev_user' )
                        : array( 'cur' => 'cur_user', 'old' => 'old_user' );
                foreach ( $set as $table => $field ) {
                        $this->reassignEditsOn( $table, $field, $from, $to );
                }
        }

        function reassignEditsOn( $table, $field, $from, $to ) {
                $this->out( "reassigning on $table... " );
                $this->db->update( $table,
                        array( $field => $to ),
                        array( $field => $from ),
                        __METHOD__ );
                $this->out( "ok. " );
        }

        function trimAccount( $userid ) {
                $this->out( "deleting..." );
                $this->db->delete( 'user', array( 'user_id' => $userid ), __METHOD__ );
                $this->out( " ok" );
        }

}