MediaWiki 1.30.2

[autoinstallsdev/mediawiki.git] / maintenance / runBatchedQuery.php

diff --git a/maintenance/runBatchedQuery.php b/maintenance/runBatchedQuery.php
index dd3680c983635a430dced36dcb1bcc353eb17b75..b0a2b9242834440a0596e9a54205cd10093c107c 100644 (file)
--- a/maintenance/runBatchedQuery.php
+++ b/maintenance/runBatchedQuery.php
@@ -1,6 +1,6 @@
 <?php
 /**
- * Run a database query in batches and wait for slaves. This is used on large
+ * Run a database query in batches and wait for replica DBs. This is used on large
  * wikis to prevent replication lag from going through the roof when executing
  * large write queries.
  *
@@ -19,35 +19,91 @@
  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  * http://www.gnu.org/copyleft/gpl.html
  *
+ * @file
  * @ingroup Maintenance
  */
 
-require_once( dirname( __FILE__ ) . '/Maintenance.php' );
+require_once __DIR__ . '/Maintenance.php';
 
+use Wikimedia\Rdbms\IDatabase;
+
+/**
+ * Maintenance script to run a database query in batches and wait for replica DBs.
+ *
+ * @ingroup Maintenance
+ */
 class BatchedQueryRunner extends Maintenance {
        public function __construct() {
                parent::__construct();
-               $this->mDescription = "Run a query repeatedly until it affects 0 rows, and wait for slaves in between.\n" .
-                               "NOTE: You need to set a LIMIT clause yourself.";
-               $this->addOption( 'wait', "Wait for replication lag to go down to this value. Default: 5", false, true );
+               $this->addDescription(
+                       "Run an update query on all rows of a table. " .
+                       "Waits for replicas at appropriate intervals." );
+               $this->addOption( 'table', 'The table name', true, true );
+               $this->addOption( 'set', 'The SET clause', true, true );
+               $this->addOption( 'where', 'The WHERE clause', false, true );
+               $this->addOption( 'key', 'A column name, the values of which are unique', true, true );
+               $this->addOption( 'batch-size', 'The batch size (default 1000)', false, true );
+               $this->addOption( 'db', 'The database name, or omit to use the current wiki.', false, true );
        }
 
        public function execute() {
-               if ( !$this->hasArg() )
-                       $this->error( "No query specified. Specify the query as a command line parameter.", true );
+               $table = $this->getOption( 'table' );
+               $key = $this->getOption( 'key' );
+               $set = $this->getOption( 'set' );
+               $where = $this->getOption( 'where', null );
+               $where = $where === null ? [] : [ $where ];
+               $batchSize = $this->getOption( 'batch-size', 1000 );
+
+               $dbName = $this->getOption( 'db', null );
+               if ( $dbName === null ) {
+                       $dbw = $this->getDB( DB_MASTER );
+               } else {
+                       $lbf = MediaWiki\MediaWikiServices::getInstance()->getDBLoadBalancerFactory();
+                       $lb = $lbf->getMainLB( $dbName );
+                       $dbw = $lb->getConnection( DB_MASTER, [], $dbName );
+               }
+
+               $selectConds = $where;
+               $prevEnd = false;
 
-               $query = $this->getArg();
-               $wait = $this->getOption( 'wait', 5 );
                $n = 1;
-               $dbw = wfGetDb( DB_MASTER );
                do {
                        $this->output( "Batch $n: " );
                        $n++;
+
+                       // Note that the update conditions do not rely on atomicity of the
+                       // SELECT query in order to guarantee that all rows are updated. The
+                       // results of the SELECT are merely a partitioning hint. Simultaneous
+                       // updates merely result in the wrong number of rows being updated
+                       // in a batch.
+
+                       $res = $dbw->select( $table, $key, $selectConds, __METHOD__,
+                               [ 'ORDER BY' => $key, 'LIMIT' => $batchSize ] );
+                       if ( $res->numRows() ) {
+                               $res->seek( $res->numRows() - 1 );
+                               $row = $res->fetchObject();
+                               $end = $dbw->addQuotes( $row->$key );
+                               $selectConds = array_merge( $where, [ "$key > $end" ] );
+                               $updateConds = array_merge( $where, [ "$key <= $end" ] );
+                       } else {
+                               $updateConds = $where;
+                       }
+                       if ( $prevEnd !== false ) {
+                               $updateConds = array_merge( [ "$key > $prevEnd" ], $updateConds );
+                       }
+
+                       $query = "UPDATE " . $dbw->tableName( $table ) .
+                               " SET " . $set .
+                               " WHERE " . $dbw->makeList( $updateConds, IDatabase::LIST_AND );
+
                        $dbw->query( $query, __METHOD__ );
+
+                       $prevEnd = $end;
+
                        $affected = $dbw->affectedRows();
-                       $this->output( "$affected rows\n" );
-                       wfWaitForSlaves( $wait );
-               } while ( $affected > 0 );
+                       $this->output( "$affected rows affected\n" );
+                       wfWaitForSlaves();
+               } while ( $res->numRows() );
        }
 
        public function getDbType() {
@@ -55,6 +111,5 @@ class BatchedQueryRunner extends Maintenance {
        }
 }
 
-
 $maintClass = "BatchedQueryRunner";
-require_once( RUN_MAINTENANCE_IF_MAIN );
+require_once RUN_MAINTENANCE_IF_MAIN;