tests/phpunit/includes/db/LBFactoryTest.php

   1 <?php
   2 /**
   3  * Holds tests for LBFactory abstract MediaWiki class.
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License along
  16  * with this program; if not, write to the Free Software Foundation, Inc.,
  17  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  18  * http://www.gnu.org/copyleft/gpl.html
  19  *
  20  * @file
  21  * @author Antoine Musso
  22  * @copyright © 2013 Antoine Musso
  23  * @copyright © 2013 Wikimedia Foundation Inc.
  24  */
  25
  26 use Wikimedia\Rdbms\LBFactorySimple;
  27 use Wikimedia\Rdbms\LBFactoryMulti;
  28 use Wikimedia\Rdbms\LoadBalancer;
  29 use Wikimedia\Rdbms\ChronologyProtector;
  30 use Wikimedia\Rdbms\DatabaseMysqli;
  31 use Wikimedia\Rdbms\MySQLMasterPos;
  32 use Wikimedia\Rdbms\DatabaseDomain;
  33
  34 /**
  35  * @group Database
  36  * @covers \Wikimedia\Rdbms\LBFactorySimple
  37  * @covers \Wikimedia\Rdbms\LBFactoryMulti
  38  */
  39 class LBFactoryTest extends MediaWikiTestCase {
  40
  41         /**
  42          * @covers MWLBFactory::getLBFactoryClass
  43          * @dataProvider getLBFactoryClassProvider
  44          */
  45         public function testGetLBFactoryClass( $expected, $deprecated ) {
  46                 $mockDB = $this->getMockBuilder( DatabaseMysqli::class )
  47                         ->disableOriginalConstructor()
  48                         ->getMock();
  49
  50                 $config = [
  51                         'class'          => $deprecated,
  52                         'connection'     => $mockDB,
  53                         # Various other parameters required:
  54                         'sectionsByDB'   => [],
  55                         'sectionLoads'   => [],
  56                         'serverTemplate' => [],
  57                 ];
  58
  59                 $this->hideDeprecated( '$wgLBFactoryConf must be updated. See RELEASE-NOTES for details' );
  60                 $result = MWLBFactory::getLBFactoryClass( $config );
  61
  62                 $this->assertEquals( $expected, $result );
  63         }
  64
  65         public function getLBFactoryClassProvider() {
  66                 return [
  67                         # Format: new class, old class
  68                         [ Wikimedia\Rdbms\LBFactorySimple::class, 'LBFactory_Simple' ],
  69                         [ Wikimedia\Rdbms\LBFactorySingle::class, 'LBFactory_Single' ],
  70                         [ Wikimedia\Rdbms\LBFactoryMulti::class, 'LBFactory_Multi' ],
  71                         [ Wikimedia\Rdbms\LBFactorySimple::class, 'LBFactorySimple' ],
  72                         [ Wikimedia\Rdbms\LBFactorySingle::class, 'LBFactorySingle' ],
  73                         [ Wikimedia\Rdbms\LBFactoryMulti::class, 'LBFactoryMulti' ],
  74                 ];
  75         }
  76
  77         public function testLBFactorySimpleServer() {
  78                 global $wgDBserver, $wgDBname, $wgDBuser, $wgDBpassword, $wgDBtype, $wgSQLiteDataDir;
  79
  80                 $servers = [
  81                         [
  82                                 'host'        => $wgDBserver,
  83                                 'dbname'      => $wgDBname,
  84                                 'user'        => $wgDBuser,
  85                                 'password'    => $wgDBpassword,
  86                                 'type'        => $wgDBtype,
  87                                 'dbDirectory' => $wgSQLiteDataDir,
  88                                 'load'        => 0,
  89                                 'flags'       => DBO_TRX // REPEATABLE-READ for consistency
  90                         ],
  91                 ];
  92
  93                 $factory = new LBFactorySimple( [ 'servers' => $servers ] );
  94                 $lb = $factory->getMainLB();
  95
  96                 $dbw = $lb->getConnection( DB_MASTER );
  97                 $this->assertTrue( $dbw->getLBInfo( 'master' ), 'master shows as master' );
  98
  99                 $dbr = $lb->getConnection( DB_REPLICA );
 100                 $this->assertTrue( $dbr->getLBInfo( 'master' ), 'DB_REPLICA also gets the master' );
 101
 102                 $factory->shutdown();
 103                 $lb->closeAll();
 104         }
 105
 106         public function testLBFactorySimpleServers() {
 107                 global $wgDBserver, $wgDBname, $wgDBuser, $wgDBpassword, $wgDBtype, $wgSQLiteDataDir;
 108
 109                 $servers = [
 110                         [ // master
 111                                 'host'        => $wgDBserver,
 112                                 'dbname'      => $wgDBname,
 113                                 'user'        => $wgDBuser,
 114                                 'password'    => $wgDBpassword,
 115                                 'type'        => $wgDBtype,
 116                                 'dbDirectory' => $wgSQLiteDataDir,
 117                                 'load'        => 0,
 118                                 'flags'       => DBO_TRX // REPEATABLE-READ for consistency
 119                         ],
 120                         [ // emulated slave
 121                                 'host'        => $wgDBserver,
 122                                 'dbname'      => $wgDBname,
 123                                 'user'        => $wgDBuser,
 124                                 'password'    => $wgDBpassword,
 125                                 'type'        => $wgDBtype,
 126                                 'dbDirectory' => $wgSQLiteDataDir,
 127                                 'load'        => 100,
 128                                 'flags'       => DBO_TRX // REPEATABLE-READ for consistency
 129                         ]
 130                 ];
 131
 132                 $factory = new LBFactorySimple( [
 133                         'servers' => $servers,
 134                         'loadMonitorClass' => LoadMonitorNull::class
 135                 ] );
 136                 $lb = $factory->getMainLB();
 137
 138                 $dbw = $lb->getConnection( DB_MASTER );
 139                 $this->assertTrue( $dbw->getLBInfo( 'master' ), 'master shows as master' );
 140                 $this->assertEquals(
 141                         ( $wgDBserver != '' ) ? $wgDBserver : 'localhost',
 142                         $dbw->getLBInfo( 'clusterMasterHost' ),
 143                         'cluster master set' );
 144
 145                 $dbr = $lb->getConnection( DB_REPLICA );
 146                 $this->assertTrue( $dbr->getLBInfo( 'replica' ), 'slave shows as slave' );
 147                 $this->assertEquals(
 148                         ( $wgDBserver != '' ) ? $wgDBserver : 'localhost',
 149                         $dbr->getLBInfo( 'clusterMasterHost' ),
 150                         'cluster master set' );
 151
 152                 $factory->shutdown();
 153                 $lb->closeAll();
 154         }
 155
 156         public function testLBFactoryMulti() {
 157                 global $wgDBserver, $wgDBname, $wgDBuser, $wgDBpassword, $wgDBtype, $wgSQLiteDataDir;
 158
 159                 $factory = new LBFactoryMulti( [
 160                         'sectionsByDB' => [
 161                                 's1wiki' => 's1',
 162                         ],
 163                         'sectionLoads' => [
 164                                 's1' => [
 165                                         'test-db3' => 0,
 166                                         'test-db4' => 100,
 167                                 ],
 168                                 'DEFAULT' => [
 169                                         'test-db1' => 0,
 170                                         'test-db2' => 100,
 171                                 ]
 172                         ],
 173                         'serverTemplate' => [
 174                                 'dbname'      => $wgDBname,
 175                                 'user'        => $wgDBuser,
 176                                 'password'    => $wgDBpassword,
 177                                 'type'        => $wgDBtype,
 178                                 'dbDirectory' => $wgSQLiteDataDir,
 179                                 'flags'       => DBO_DEFAULT
 180                         ],
 181                         'hostsByName' => [
 182                                 'test-db1'  => $wgDBserver,
 183                                 'test-db2'  => $wgDBserver,
 184                                 'test-db3'  => $wgDBserver,
 185                                 'test-db4'  => $wgDBserver
 186                         ],
 187                         'loadMonitorClass' => LoadMonitorNull::class
 188                 ] );
 189                 $lb = $factory->getMainLB();
 190
 191                 $dbw = $lb->getConnection( DB_MASTER );
 192                 $this->assertTrue( $dbw->getLBInfo( 'master' ), 'master shows as master' );
 193
 194                 $dbr = $lb->getConnection( DB_REPLICA );
 195                 $this->assertTrue( $dbr->getLBInfo( 'replica' ), 'slave shows as slave' );
 196
 197                 // Test that LoadBalancer instances made during commitMasterChanges() do not throw
 198                 // DBTransactionError due to transaction ROUND_* stages being mismatched.
 199                 $factory->beginMasterChanges( __METHOD__ );
 200                 $dbw->onTransactionPreCommitOrIdle( function () use ( $factory ) {
 201                         // Trigger s1 LoadBalancer instantiation during "finalize" stage.
 202                         // There is no s1wiki DB to select so it is not in getConnection(),
 203                         // but this fools getMainLB() at least.
 204                         $factory->getMainLB( 's1wiki' )->getConnection( DB_MASTER );
 205                 } );
 206                 $factory->commitMasterChanges( __METHOD__ );
 207
 208                 $count = 0;
 209                 $factory->forEachLB( function () use ( &$count ) {
 210                         ++$count;
 211                 } );
 212                 $this->assertEquals( 2, $count );
 213
 214                 // DBTransactionError should not be thrown
 215                 $ran = 0;
 216                 $dbw->onTransactionPreCommitOrIdle( function () use ( &$ran ) {
 217                         ++$ran;
 218                 } );
 219                 $factory->commitAll( __METHOD__ );
 220                 $this->assertEquals( 1, $ran );
 221
 222                 $factory->shutdown();
 223                 $factory->closeAll();
 224         }
 225
 226         /**
 227          * @covers \Wikimedia\Rdbms\ChronologyProtector
 228          */
 229         public function testChronologyProtector() {
 230                 $now = microtime( true );
 231
 232                 // (a) First HTTP request
 233                 $m1Pos = new MySQLMasterPos( 'db1034-bin.000976/843431247', $now );
 234                 $m2Pos = new MySQLMasterPos( 'db1064-bin.002400/794074907', $now );
 235
 236                 // Master DB 1
 237                 $mockDB1 = $this->getMockBuilder( DatabaseMysqli::class )
 238                         ->disableOriginalConstructor()
 239                         ->getMock();
 240                 $mockDB1->method( 'writesOrCallbacksPending' )->willReturn( true );
 241                 $mockDB1->method( 'lastDoneWrites' )->willReturn( $now );
 242                 $mockDB1->method( 'getMasterPos' )->willReturn( $m1Pos );
 243                 // Load balancer for master DB 1
 244                 $lb1 = $this->getMockBuilder( LoadBalancer::class )
 245                         ->disableOriginalConstructor()
 246                         ->getMock();
 247                 $lb1->method( 'getConnection' )->willReturn( $mockDB1 );
 248                 $lb1->method( 'getServerCount' )->willReturn( 2 );
 249                 $lb1->method( 'getAnyOpenConnection' )->willReturn( $mockDB1 );
 250                 $lb1->method( 'hasOrMadeRecentMasterChanges' )->will( $this->returnCallback(
 251                                 function () use ( $mockDB1 ) {
 252                                         $p = 0;
 253                                         $p |= call_user_func( [ $mockDB1, 'writesOrCallbacksPending' ] );
 254                                         $p |= call_user_func( [ $mockDB1, 'lastDoneWrites' ] );
 255
 256                                         return (bool)$p;
 257                                 }
 258                         ) );
 259                 $lb1->method( 'getMasterPos' )->willReturn( $m1Pos );
 260                 $lb1->method( 'getServerName' )->with( 0 )->willReturn( 'master1' );
 261                 // Master DB 2
 262                 $mockDB2 = $this->getMockBuilder( DatabaseMysqli::class )
 263                         ->disableOriginalConstructor()
 264                         ->getMock();
 265                 $mockDB2->method( 'writesOrCallbacksPending' )->willReturn( true );
 266                 $mockDB2->method( 'lastDoneWrites' )->willReturn( $now );
 267                 $mockDB2->method( 'getMasterPos' )->willReturn( $m2Pos );
 268                 // Load balancer for master DB 2
 269                 $lb2 = $this->getMockBuilder( LoadBalancer::class )
 270                         ->disableOriginalConstructor()
 271                         ->getMock();
 272                 $lb2->method( 'getConnection' )->willReturn( $mockDB2 );
 273                 $lb2->method( 'getServerCount' )->willReturn( 2 );
 274                 $lb2->method( 'getAnyOpenConnection' )->willReturn( $mockDB2 );
 275                 $lb2->method( 'hasOrMadeRecentMasterChanges' )->will( $this->returnCallback(
 276                         function () use ( $mockDB2 ) {
 277                                 $p = 0;
 278                                 $p |= call_user_func( [ $mockDB2, 'writesOrCallbacksPending' ] );
 279                                 $p |= call_user_func( [ $mockDB2, 'lastDoneWrites' ] );
 280
 281                                 return (bool)$p;
 282                         }
 283                 ) );
 284                 $lb2->method( 'getMasterPos' )->willReturn( $m2Pos );
 285                 $lb2->method( 'getServerName' )->with( 0 )->willReturn( 'master2' );
 286
 287                 $bag = new HashBagOStuff();
 288                 $cp = new ChronologyProtector(
 289                         $bag,
 290                         [
 291                                 'ip' => '127.0.0.1',
 292                                 'agent' => "Totally-Not-FireFox"
 293                         ]
 294                 );
 295
 296                 $mockDB1->expects( $this->exactly( 1 ) )->method( 'writesOrCallbacksPending' );
 297                 $mockDB1->expects( $this->exactly( 1 ) )->method( 'lastDoneWrites' );
 298                 $mockDB2->expects( $this->exactly( 1 ) )->method( 'writesOrCallbacksPending' );
 299                 $mockDB2->expects( $this->exactly( 1 ) )->method( 'lastDoneWrites' );
 300
 301                 // Nothing to wait for on first HTTP request start
 302                 $cp->initLB( $lb1 );
 303                 $cp->initLB( $lb2 );
 304                 // Record positions in stash on first HTTP request end
 305                 $cp->shutdownLB( $lb1 );
 306                 $cp->shutdownLB( $lb2 );
 307                 $cpIndex = null;
 308                 $cp->shutdown( null, 'sync', $cpIndex );
 309
 310                 $this->assertEquals( 1, $cpIndex, "CP write index set" );
 311
 312                 // (b) Second HTTP request
 313
 314                 // Load balancer for master DB 1
 315                 $lb1 = $this->getMockBuilder( LoadBalancer::class )
 316                         ->disableOriginalConstructor()
 317                         ->getMock();
 318                 $lb1->method( 'getServerCount' )->willReturn( 2 );
 319                 $lb1->method( 'getServerName' )->with( 0 )->willReturn( 'master1' );
 320                 $lb1->expects( $this->once() )
 321                         ->method( 'waitFor' )->with( $this->equalTo( $m1Pos ) );
 322                 // Load balancer for master DB 2
 323                 $lb2 = $this->getMockBuilder( LoadBalancer::class )
 324                         ->disableOriginalConstructor()
 325                         ->getMock();
 326                 $lb2->method( 'getServerCount' )->willReturn( 2 );
 327                 $lb2->method( 'getServerName' )->with( 0 )->willReturn( 'master2' );
 328                 $lb2->expects( $this->once() )
 329                         ->method( 'waitFor' )->with( $this->equalTo( $m2Pos ) );
 330
 331                 $cp = new ChronologyProtector(
 332                         $bag,
 333                         [
 334                                 'ip' => '127.0.0.1',
 335                                 'agent' => "Totally-Not-FireFox"
 336                         ],
 337                         $cpIndex
 338                 );
 339
 340                 // Wait for last positions to be reached on second HTTP request start
 341                 $cp->initLB( $lb1 );
 342                 $cp->initLB( $lb2 );
 343                 // Shutdown (nothing to record)
 344                 $cp->shutdownLB( $lb1 );
 345                 $cp->shutdownLB( $lb2 );
 346                 $cpIndex = null;
 347                 $cp->shutdown( null, 'sync', $cpIndex );
 348
 349                 $this->assertEquals( null, $cpIndex, "CP write index retained" );
 350         }
 351
 352         private function newLBFactoryMulti( array $baseOverride = [], array $serverOverride = [] ) {
 353                 global $wgDBserver, $wgDBuser, $wgDBpassword, $wgDBname, $wgDBprefix, $wgDBtype;
 354                 global $wgSQLiteDataDir;
 355
 356                 return new LBFactoryMulti( $baseOverride + [
 357                         'sectionsByDB' => [],
 358                         'sectionLoads' => [
 359                                 'DEFAULT' => [
 360                                         'test-db1' => 1,
 361                                 ],
 362                         ],
 363                         'serverTemplate' => $serverOverride + [
 364                                 'dbname' => $wgDBname,
 365                                 'tablePrefix' => $wgDBprefix,
 366                                 'user' => $wgDBuser,
 367                                 'password' => $wgDBpassword,
 368                                 'type' => $wgDBtype,
 369                                 'dbDirectory' => $wgSQLiteDataDir,
 370                                 'flags' => DBO_DEFAULT
 371                         ],
 372                         'hostsByName' => [
 373                                 'test-db1' => $wgDBserver,
 374                         ],
 375                         'loadMonitorClass' => LoadMonitorNull::class,
 376                         'localDomain' => new DatabaseDomain( $wgDBname, null, $wgDBprefix )
 377                 ] );
 378         }
 379
 380         public function testNiceDomains() {
 381                 global $wgDBname;
 382
 383                 if ( wfGetDB( DB_MASTER )->databasesAreIndependent() ) {
 384                         self::markTestSkipped( "Skipping tests about selecting DBs: not applicable" );
 385                         return;
 386                 }
 387
 388                 $factory = $this->newLBFactoryMulti(
 389                         [],
 390                         []
 391                 );
 392                 $lb = $factory->getMainLB();
 393
 394                 $db = $lb->getConnectionRef( DB_MASTER );
 395                 $this->assertEquals(
 396                         wfWikiID(),
 397                         $db->getDomainID()
 398                 );
 399                 unset( $db );
 400
 401                 /** @var Database $db */
 402                 $db = $lb->getConnection( DB_MASTER, [], '' );
 403
 404                 $this->assertEquals(
 405                         '',
 406                         $db->getDomainId(),
 407                         'Null domain ID handle used'
 408                 );
 409                 $this->assertEquals(
 410                         '',
 411                         $db->getDBname(),
 412                         'Null domain ID handle used'
 413                 );
 414                 $this->assertEquals(
 415                         '',
 416                         $db->tablePrefix(),
 417                         'Main domain ID handle used; prefix is empty though'
 418                 );
 419                 $this->assertEquals(
 420                         $this->quoteTable( $db, 'page' ),
 421                         $db->tableName( 'page' ),
 422                         "Correct full table name"
 423                 );
 424                 $this->assertEquals(
 425                         $this->quoteTable( $db, $wgDBname ) . '.' . $this->quoteTable( $db, 'page' ),
 426                         $db->tableName( "$wgDBname.page" ),
 427                         "Correct full table name"
 428                 );
 429                 $this->assertEquals(
 430                         $this->quoteTable( $db, 'nice_db' ) . '.' . $this->quoteTable( $db, 'page' ),
 431                         $db->tableName( 'nice_db.page' ),
 432                         "Correct full table name"
 433                 );
 434
 435                 $lb->reuseConnection( $db ); // don't care
 436
 437                 $db = $lb->getConnection( DB_MASTER ); // local domain connection
 438                 $factory->setDomainPrefix( 'my_' );
 439
 440                 $this->assertEquals( $wgDBname, $db->getDBname() );
 441                 $this->assertEquals(
 442                         "$wgDBname-my_",
 443                         $db->getDomainID()
 444                 );
 445                 $this->assertEquals(
 446                         $this->quoteTable( $db, 'my_page' ),
 447                         $db->tableName( 'page' ),
 448                         "Correct full table name"
 449                 );
 450                 $this->assertEquals(
 451                         $this->quoteTable( $db, 'other_nice_db' ) . '.' . $this->quoteTable( $db, 'page' ),
 452                         $db->tableName( 'other_nice_db.page' ),
 453                         "Correct full table name"
 454                 );
 455
 456                 $factory->closeAll();
 457                 $factory->destroy();
 458         }
 459
 460         public function testTrickyDomain() {
 461                 global $wgDBname;
 462
 463                 if ( wfGetDB( DB_MASTER )->databasesAreIndependent() ) {
 464                         self::markTestSkipped( "Skipping tests about selecting DBs: not applicable" );
 465                         return;
 466                 }
 467
 468                 $dbname = 'unittest-domain'; // explodes if DB is selected
 469                 $factory = $this->newLBFactoryMulti(
 470                         [ 'localDomain' => ( new DatabaseDomain( $dbname, null, '' ) )->getId() ],
 471                         [
 472                                 'dbName' => 'do_not_select_me' // explodes if DB is selected
 473                         ]
 474                 );
 475                 $lb = $factory->getMainLB();
 476                 /** @var Database $db */
 477                 $db = $lb->getConnection( DB_MASTER, [], '' );
 478
 479                 $this->assertEquals( '', $db->getDomainID(), "Null domain used" );
 480
 481                 $this->assertEquals(
 482                         $this->quoteTable( $db, 'page' ),
 483                         $db->tableName( 'page' ),
 484                         "Correct full table name"
 485                 );
 486
 487                 $this->assertEquals(
 488                         $this->quoteTable( $db, $dbname ) . '.' . $this->quoteTable( $db, 'page' ),
 489                         $db->tableName( "$dbname.page" ),
 490                         "Correct full table name"
 491                 );
 492
 493                 $this->assertEquals(
 494                         $this->quoteTable( $db, 'nice_db' ) . '.' . $this->quoteTable( $db, 'page' ),
 495                         $db->tableName( 'nice_db.page' ),
 496                         "Correct full table name"
 497                 );
 498
 499                 $lb->reuseConnection( $db ); // don't care
 500
 501                 $factory->setDomainPrefix( 'my_' );
 502                 $db = $lb->getConnection( DB_MASTER, [], "$wgDBname-my_" );
 503
 504                 $this->assertEquals(
 505                         $this->quoteTable( $db, 'my_page' ),
 506                         $db->tableName( 'page' ),
 507                         "Correct full table name"
 508                 );
 509                 $this->assertEquals(
 510                         $this->quoteTable( $db, 'other_nice_db' ) . '.' . $this->quoteTable( $db, 'page' ),
 511                         $db->tableName( 'other_nice_db.page' ),
 512                         "Correct full table name"
 513                 );
 514                 $this->assertEquals(
 515                         $this->quoteTable( $db, 'garbage-db' ) . '.' . $this->quoteTable( $db, 'page' ),
 516                         $db->tableName( 'garbage-db.page' ),
 517                         "Correct full table name"
 518                 );
 519
 520                 $lb->reuseConnection( $db ); // don't care
 521
 522                 $factory->closeAll();
 523                 $factory->destroy();
 524         }
 525
 526         public function testInvalidSelectDB() {
 527                 $dbname = 'unittest-domain'; // explodes if DB is selected
 528                 $factory = $this->newLBFactoryMulti(
 529                         [ 'localDomain' => ( new DatabaseDomain( $dbname, null, '' ) )->getId() ],
 530                         [
 531                                 'dbName' => 'do_not_select_me' // explodes if DB is selected
 532                         ]
 533                 );
 534                 $lb = $factory->getMainLB();
 535                 /** @var Database $db */
 536                 $db = $lb->getConnection( DB_MASTER, [], '' );
 537
 538                 if ( $db->getType() === 'sqlite' ) {
 539                         $this->assertFalse( $db->selectDB( 'garbage-db' ) );
 540                 } elseif ( $db->databasesAreIndependent() ) {
 541                         try {
 542                                 $e = null;
 543                                 $db->selectDB( 'garbage-db' );
 544                         } catch ( \Wikimedia\Rdbms\DBConnectionError $e ) {
 545                                 // expected
 546                         }
 547                         $this->assertInstanceOf( \Wikimedia\Rdbms\DBConnectionError::class, $e );
 548                         $this->assertFalse( $db->isOpen() );
 549                 } else {
 550                         \Wikimedia\suppressWarnings();
 551                         $this->assertFalse( $db->selectDB( 'garbage-db' ) );
 552                         \Wikimedia\restoreWarnings();
 553                 }
 554         }
 555
 556         private function quoteTable( Database $db, $table ) {
 557                 if ( $db->getType() === 'sqlite' ) {
 558                         return $table;
 559                 } else {
 560                         return $db->addIdentifierQuotes( $table );
 561                 }
 562         }
 563 }