includes/Database.php

   1 <?php
   2 /**
   3  * This file deals with MySQL interface functions
   4  * and query specifics/optimisations
   5  * @package MediaWiki
   6  */
   7
   8 /**
   9  * Depends on the CacheManager
  10  */
  11 require_once( 'CacheManager.php' );
  12
  13 /** See Database::makeList() */
  14 define( 'LIST_COMMA', 0 );
  15 define( 'LIST_AND', 1 );
  16 define( 'LIST_SET', 2 );
  17 define( 'LIST_NAMES', 3);
  18
  19 /** Number of times to re-try an operation in case of deadlock */
  20 define( 'DEADLOCK_TRIES', 4 );
  21 /** Minimum time to wait before retry, in microseconds */
  22 define( 'DEADLOCK_DELAY_MIN', 500000 );
  23 /** Maximum time to wait before retry */
  24 define( 'DEADLOCK_DELAY_MAX', 1500000 );
  25
  26 class DBObject {
  27         var $mData;
  28
  29         function DBObject($data) {
  30                 $this->mData = $data;
  31         }
  32
  33         function isLOB() {
  34                 return false;
  35         }
  36
  37         function data() {
  38                 return $this->mData;
  39         }
  40 };
  41
  42 /**
  43  * Database abstraction object
  44  * @package MediaWiki
  45  */
  46 class Database {
  47
  48 #------------------------------------------------------------------------------
  49 # Variables
  50 #------------------------------------------------------------------------------
  51         /**#@+
  52          * @access private
  53          */
  54         var $mLastQuery = '';
  55
  56         var $mServer, $mUser, $mPassword, $mConn = null, $mDBname;
  57         var $mOut, $mOpened = false;
  58
  59         var $mFailFunction;
  60         var $mTablePrefix;
  61         var $mFlags;
  62         var $mTrxLevel = 0;
  63         var $mErrorCount = 0;
  64         /**#@-*/
  65
  66 #------------------------------------------------------------------------------
  67 # Accessors
  68 #------------------------------------------------------------------------------
  69         # These optionally set a variable and return the previous state
  70
  71         /**
  72          * Fail function, takes a Database as a parameter
  73          * Set to false for default, 1 for ignore errors
  74          */
  75         function failFunction( $function = NULL ) {
  76                 return wfSetVar( $this->mFailFunction, $function );
  77         }
  78
  79         /**
  80          * Output page, used for reporting errors
  81          * FALSE means discard output
  82          */
  83         function &setOutputPage( &$out ) {
  84                 $this->mOut =& $out;
  85         }
  86
  87         /**
  88          * Boolean, controls output of large amounts of debug information
  89          */
  90         function debug( $debug = NULL ) {
  91                 return wfSetBit( $this->mFlags, DBO_DEBUG, $debug );
  92         }
  93
  94         /**
  95          * Turns buffering of SQL result sets on (true) or off (false).
  96          * Default is "on" and it should not be changed without good reasons.
  97          */
  98         function bufferResults( $buffer = NULL ) {
  99                 if ( is_null( $buffer ) ) {
 100                         return !(bool)( $this->mFlags & DBO_NOBUFFER );
 101                 } else {
 102                         return !wfSetBit( $this->mFlags, DBO_NOBUFFER, !$buffer );
 103                 }
 104         }
 105
 106         /**
 107          * Turns on (false) or off (true) the automatic generation and sending
 108          * of a "we're sorry, but there has been a database error" page on
 109          * database errors. Default is on (false). When turned off, the
 110          * code should use wfLastErrno() and wfLastError() to handle the
 111          * situation as appropriate.
 112          */
 113         function ignoreErrors( $ignoreErrors = NULL ) {
 114                 return wfSetBit( $this->mFlags, DBO_IGNORE, $ignoreErrors );
 115         }
 116
 117         /**
 118          * The current depth of nested transactions
 119          * @param integer $level
 120          */
 121         function trxLevel( $level = NULL ) {
 122                 return wfSetVar( $this->mTrxLevel, $level );
 123         }
 124
 125         /**
 126          * Number of errors logged, only useful when errors are ignored
 127          */
 128         function errorCount( $count = NULL ) {
 129                 return wfSetVar( $this->mErrorCount, $count );
 130         }
 131
 132         /**#@+
 133          * Get function
 134          */
 135         function lastQuery() { return $this->mLastQuery; }
 136         function isOpen() { return $this->mOpened; }
 137         /**#@-*/
 138
 139 #------------------------------------------------------------------------------
 140 # Other functions
 141 #------------------------------------------------------------------------------
 142
 143         /**#@+
 144          * @param string $server database server host
 145          * @param string $user database user name
 146          * @param string $password database user password
 147          * @param string $dbname database name
 148          */
 149
 150         /**
 151          * @param failFunction
 152          * @param $flags
 153          * @param string $tablePrefix Database table prefixes. By default use the prefix gave in LocalSettings.php
 154          */
 155         function Database( $server = false, $user = false, $password = false, $dbName = false,
 156                 $failFunction = false, $flags = 0, $tablePrefix = 'get from global' ) {
 157
 158                 global $wgOut, $wgDBprefix, $wgCommandLineMode;
 159                 # Can't get a reference if it hasn't been set yet
 160                 if ( !isset( $wgOut ) ) {
 161                         $wgOut = NULL;
 162                 }
 163                 $this->mOut =& $wgOut;
 164
 165                 $this->mFailFunction = $failFunction;
 166                 $this->mFlags = $flags;
 167
 168                 if ( $this->mFlags & DBO_DEFAULT ) {
 169                         if ( $wgCommandLineMode ) {
 170                                 $this->mFlags &= ~DBO_TRX;
 171                         } else {
 172                                 $this->mFlags |= DBO_TRX;
 173                         }
 174                 }
 175
 176                 /*
 177                 // Faster read-only access
 178                 if ( wfReadOnly() ) {
 179                         $this->mFlags |= DBO_PERSISTENT;
 180                         $this->mFlags &= ~DBO_TRX;
 181                 }*/
 182
 183                 /** Get the default table prefix*/
 184                 if ( $tablePrefix == 'get from global' ) {
 185                         $this->mTablePrefix = $wgDBprefix;
 186                 } else {
 187                         $this->mTablePrefix = $tablePrefix;
 188                 }
 189
 190                 if ( $server ) {
 191                         $this->open( $server, $user, $password, $dbName );
 192                 }
 193         }
 194
 195         /**
 196          * @static
 197          * @param failFunction
 198          * @param $flags
 199          */
 200         function newFromParams( $server, $user, $password, $dbName,
 201                 $failFunction = false, $flags = 0 )
 202         {
 203                 return new Database( $server, $user, $password, $dbName, $failFunction, $flags );
 204         }
 205
 206         /**
 207          * Usually aborts on failure
 208          * If the failFunction is set to a non-zero integer, returns success
 209          */
 210         function open( $server, $user, $password, $dbName ) {
 211                 # Test for missing mysql.so
 212                 # First try to load it
 213                 if (!@extension_loaded('mysql')) {
 214                         @dl('mysql.so');
 215                 }
 216
 217                 # Otherwise we get a suppressed fatal error, which is very hard to track down
 218                 if ( !function_exists( 'mysql_connect' ) ) {
 219                         die( "MySQL functions missing, have you compiled PHP with the --with-mysql option?\n" );
 220                 }
 221
 222                 $this->close();
 223                 $this->mServer = $server;
 224                 $this->mUser = $user;
 225                 $this->mPassword = $password;
 226                 $this->mDBname = $dbName;
 227
 228                 $success = false;
 229
 230                 if ( $this->mFlags & DBO_PERSISTENT ) {
 231                         @/**/$this->mConn = mysql_pconnect( $server, $user, $password );
 232                 } else {
 233                         # Create a new connection...
 234                         if( version_compare( PHP_VERSION, '4.2.0', 'ge' ) ) {
 235                                 @/**/$this->mConn = mysql_connect( $server, $user, $password, true );
 236                         } else {
 237                                 # On PHP 4.1 the new_link parameter is not available. We cannot
 238                                 # guarantee that we'll actually get a new connection, and this
 239                                 # may cause some operations to fail possibly.
 240                                 @/**/$this->mConn = mysql_connect( $server, $user, $password );
 241                         }
 242                 }
 243
 244                 if ( $dbName != '' ) {
 245                         if ( $this->mConn !== false ) {
 246                                 $success = @/**/mysql_select_db( $dbName, $this->mConn );
 247                                 if ( !$success ) {
 248                                         wfDebug( "Error selecting database \"$dbName\": " . $this->lastError() . "\n" );
 249                                 }
 250                         } else {
 251                                 wfDebug( "DB connection error\n" );
 252                                 wfDebug( "Server: $server, User: $user, Password: " .
 253                                         substr( $password, 0, 3 ) . "..., error: " . mysql_error() . "\n" );
 254                                 $success = false;
 255                         }
 256                 } else {
 257                         # Delay USE query
 258                         $success = (bool)$this->mConn;
 259                 }
 260
 261                 if ( !$success ) {
 262                         $this->reportConnectionError();
 263                 }
 264                 $this->mOpened = $success;
 265                 return $success;
 266         }
 267         /**#@-*/
 268
 269         /**
 270          * Closes a database connection.
 271          * if it is open : commits any open transactions
 272          *
 273          * @return bool operation success. true if already closed.
 274          */
 275         function close()
 276         {
 277                 $this->mOpened = false;
 278                 if ( $this->mConn ) {
 279                         if ( $this->trxLevel() ) {
 280                                 $this->immediateCommit();
 281                         }
 282                         return mysql_close( $this->mConn );
 283                 } else {
 284                         return true;
 285                 }
 286         }
 287
 288         /**
 289          * @access private
 290          * @param string $msg error message ?
 291          */
 292         function reportConnectionError() {
 293                 if ( $this->mFailFunction ) {
 294                         if ( !is_int( $this->mFailFunction ) ) {
 295                                 $ff = $this->mFailFunction;
 296                                 $ff( $this, $this->lastError() );
 297                         }
 298                 } else {
 299                         wfEmergencyAbort( $this, $this->lastError() );
 300                 }
 301         }
 302
 303         /**
 304          * Usually aborts on failure
 305          * If errors are explicitly ignored, returns success
 306          */
 307         function query( $sql, $fname = '', $tempIgnore = false ) {
 308                 global $wgProfiling, $wgCommandLineMode;
 309
 310                 if ( wfReadOnly() ) {
 311                         # This is a quick check for the most common kinds of write query used
 312                         # in MediaWiki, to provide extra safety in addition to UI-level checks.
 313                         # It is not intended to prevent every conceivable write query, or even
 314                         # to handle such queries gracefully.
 315                         if ( preg_match( '/^(update|insert|replace|delete)/i', $sql ) ) {
 316                                 wfDebug( "Write query from $fname blocked\n" );
 317                                 return false;
 318                         }
 319                 }
 320
 321                 if ( $wgProfiling ) {
 322                         # generalizeSQL will probably cut down the query to reasonable
 323                         # logging size most of the time. The substr is really just a sanity check.
 324                         $profName = 'query: ' . $fname . ' ' . substr( Database::generalizeSQL( $sql ), 0, 255 );
 325                         wfProfileIn( 'Database::query' );
 326                         wfProfileIn( $profName );
 327                 }
 328
 329                 $this->mLastQuery = $sql;
 330
 331                 # Add a comment for easy SHOW PROCESSLIST interpretation
 332                 if ( $fname ) {
 333                         $commentedSql = "/* $fname */ $sql";
 334                 } else {
 335                         $commentedSql = $sql;
 336                 }
 337
 338                 # If DBO_TRX is set, start a transaction
 339                 if ( ( $this->mFlags & DBO_TRX ) && !$this->trxLevel() && $sql != 'BEGIN' ) {
 340                         $this->begin();
 341                 }
 342
 343                 if ( $this->debug() ) {
 344                         $sqlx = substr( $commentedSql, 0, 500 );
 345                         $sqlx = strtr( $sqlx, "\t\n", '  ' );
 346                         wfDebug( "SQL: $sqlx\n" );
 347                 }
 348
 349                 # Do the query and handle errors
 350                 $ret = $this->doQuery( $commentedSql );
 351
 352                 # Try reconnecting if the connection was lost
 353                 if ( false === $ret && ( $this->lastErrno() == 2013 || $this->lastErrno() == 2006 ) ) {
 354                         # Transaction is gone, like it or not
 355                         $this->mTrxLevel = 0;
 356                         wfDebug( "Connection lost, reconnecting...\n" );
 357                         if ( $this->ping() ) {
 358                                 wfDebug( "Reconnected\n" );
 359                                 $ret = $this->doQuery( $commentedSql );
 360                         } else {
 361                                 wfDebug( "Failed\n" );
 362                         }
 363                 }
 364
 365                 if ( false === $ret ) {
 366                         $this->reportQueryError( $this->lastError(), $this->lastErrno(), $sql, $fname, $tempIgnore );
 367                 }
 368
 369                 if ( $wgProfiling ) {
 370                         wfProfileOut( $profName );
 371                         wfProfileOut( 'Database::query' );
 372                 }
 373                 return $ret;
 374         }
 375
 376         /**
 377          * The DBMS-dependent part of query()
 378          * @param string $sql SQL query.
 379          */
 380         function doQuery( $sql ) {
 381                 if( $this->bufferResults() ) {
 382                         $ret = mysql_query( $sql, $this->mConn );
 383                 } else {
 384                         $ret = mysql_unbuffered_query( $sql, $this->mConn );
 385                 }
 386                 return $ret;
 387         }
 388
 389         /**
 390          * @param $error
 391          * @param $errno
 392          * @param $sql
 393          * @param string $fname
 394          * @param bool $tempIgnore
 395          */
 396         function reportQueryError( $error, $errno, $sql, $fname, $tempIgnore = false ) {
 397                 global $wgCommandLineMode, $wgFullyInitialised;
 398                 # Ignore errors during error handling to avoid infinite recursion
 399                 $ignore = $this->ignoreErrors( true );
 400                 $this->mErrorCount ++;
 401
 402                 if( $ignore || $tempIgnore ) {
 403                         wfDebug("SQL ERROR (ignored): " . $error . "\n");
 404                 } else {
 405                         $sql1line = str_replace( "\n", "\\n", $sql );
 406                         wfLogDBError("$fname\t{$this->mServer}\t$errno\t$error\t$sql1line\n");
 407                         wfDebug("SQL ERROR: " . $error . "\n");
 408                         if ( $wgCommandLineMode || !$this->mOut || empty( $wgFullyInitialised ) ) {
 409                                 $message = "A database error has occurred\n" .
 410                                   "Query: $sql\n" .
 411                                   "Function: $fname\n" .
 412                                   "Error: $errno $error\n";
 413                                 if ( !$wgCommandLineMode ) {
 414                                         $message = nl2br( $message );
 415                                 }
 416                                 wfDebugDieBacktrace( $message );
 417                         } else {
 418                                 // this calls wfAbruptExit()
 419                                 $this->mOut->databaseError( $fname, $sql, $error, $errno );
 420                         }
 421                 }
 422                 $this->ignoreErrors( $ignore );
 423         }
 424
 425
 426         /**
 427          * Intended to be compatible with the PEAR::DB wrapper functions.
 428          * http://pear.php.net/manual/en/package.database.db.intro-execute.php
 429          *
 430          * ? = scalar value, quoted as necessary
 431          * ! = raw SQL bit (a function for instance)
 432          * & = filename; reads the file and inserts as a blob
 433          *     (we don't use this though...)
 434          */
 435         function prepare( $sql, $func = 'Database::prepare' ) {
 436                 /* MySQL doesn't support prepared statements (yet), so just
 437                    pack up the query for reference. We'll manually replace
 438                    the bits later. */
 439                 return array( 'query' => $sql, 'func' => $func );
 440         }
 441
 442         function freePrepared( $prepared ) {
 443                 /* No-op for MySQL */
 444         }
 445
 446         /**
 447          * Execute a prepared query with the various arguments
 448          * @param string $prepared the prepared sql
 449          * @param mixed $args Either an array here, or put scalars as varargs
 450          */
 451         function execute( $prepared, $args = null ) {
 452                 if( !is_array( $args ) ) {
 453                         # Pull the var args
 454                         $args = func_get_args();
 455                         array_shift( $args );
 456                 }
 457                 $sql = $this->fillPrepared( $prepared['query'], $args );
 458                 return $this->query( $sql, $prepared['func'] );
 459         }
 460
 461         /**
 462          * Prepare & execute an SQL statement, quoting and inserting arguments
 463          * in the appropriate places.
 464          * @param string $query
 465          * @param string $args ...
 466          */
 467         function safeQuery( $query, $args = null ) {
 468                 $prepared = $this->prepare( $query, 'Database::safeQuery' );
 469                 if( !is_array( $args ) ) {
 470                         # Pull the var args
 471                         $args = func_get_args();
 472                         array_shift( $args );
 473                 }
 474                 $retval = $this->execute( $prepared, $args );
 475                 $this->freePrepared( $prepared );
 476                 return $retval;
 477         }
 478
 479         /**
 480          * For faking prepared SQL statements on DBs that don't support
 481          * it directly.
 482          * @param string $preparedSql - a 'preparable' SQL statement
 483          * @param array $args - array of arguments to fill it with
 484          * @return string executable SQL
 485          */
 486         function fillPrepared( $preparedQuery, $args ) {
 487                 $n = 0;
 488                 reset( $args );
 489                 $this->preparedArgs =& $args;
 490                 return preg_replace_callback( '/(\\\\[?!&]|[?!&])/',
 491                         array( &$this, 'fillPreparedArg' ), $preparedQuery );
 492         }
 493
 494         /**
 495          * preg_callback func for fillPrepared()
 496          * The arguments should be in $this->preparedArgs and must not be touched
 497          * while we're doing this.
 498          *
 499          * @param array $matches
 500          * @return string
 501          * @access private
 502          */
 503         function fillPreparedArg( $matches ) {
 504                 switch( $matches[1] ) {
 505                         case '\\?': return '?';
 506                         case '\\!': return '!';
 507                         case '\\&': return '&';
 508                 }
 509                 list( $n, $arg ) = each( $this->preparedArgs );
 510                 switch( $matches[1] ) {
 511                         case '?': return $this->addQuotes( $arg );
 512                         case '!': return $arg;
 513                         case '&':
 514                                 # return $this->addQuotes( file_get_contents( $arg ) );
 515                                 wfDebugDieBacktrace( '& mode is not implemented. If it\'s really needed, uncomment the line above.' );
 516                         default:
 517                                 wfDebugDieBacktrace( 'Received invalid match. This should never happen!' );
 518                 }
 519         }
 520
 521         /**#@+
 522          * @param mixed $res A SQL result
 523          */
 524         /**
 525          * Free a result object
 526          */
 527         function freeResult( $res ) {
 528                 if ( !@/**/mysql_free_result( $res ) ) {
 529                         wfDebugDieBacktrace( "Unable to free MySQL result\n" );
 530                 }
 531         }
 532
 533         /**
 534          * Fetch the next row from the given result object, in object form
 535          */
 536         function fetchObject( $res ) {
 537                 @/**/$row = mysql_fetch_object( $res );
 538                 if( mysql_errno() ) {
 539                         wfDebugDieBacktrace( 'Error in fetchObject(): ' . htmlspecialchars( mysql_error() ) );
 540                 }
 541                 return $row;
 542         }
 543
 544         /**
 545          * Fetch the next row from the given result object
 546          * Returns an array
 547          */
 548         function fetchRow( $res ) {
 549                 @/**/$row = mysql_fetch_array( $res );
 550                 if (mysql_errno() ) {
 551                         wfDebugDieBacktrace( 'Error in fetchRow(): ' . htmlspecialchars( mysql_error() ) );
 552                 }
 553                 return $row;
 554         }
 555
 556         /**
 557          * Get the number of rows in a result object
 558          */
 559         function numRows( $res ) {
 560                 @/**/$n = mysql_num_rows( $res );
 561                 if( mysql_errno() ) {
 562                         wfDebugDieBacktrace( 'Error in numRows(): ' . htmlspecialchars( mysql_error() ) );
 563                 }
 564                 return $n;
 565         }
 566
 567         /**
 568          * Get the number of fields in a result object
 569          * See documentation for mysql_num_fields()
 570          */
 571         function numFields( $res ) { return mysql_num_fields( $res ); }
 572
 573         /**
 574          * Get a field name in a result object
 575          * See documentation for mysql_field_name()
 576          */
 577         function fieldName( $res, $n ) { return mysql_field_name( $res, $n ); }
 578
 579         /**
 580          * Get the inserted value of an auto-increment row
 581          *
 582          * The value inserted should be fetched from nextSequenceValue()
 583          *
 584          * Example:
 585          * $id = $dbw->nextSequenceValue('page_page_id_seq');
 586          * $dbw->insert('page',array('page_id' => $id));
 587          * $id = $dbw->insertId();
 588          */
 589         function insertId() { return mysql_insert_id( $this->mConn ); }
 590
 591         /**
 592          * Change the position of the cursor in a result object
 593          * See mysql_data_seek()
 594          */
 595         function dataSeek( $res, $row ) { return mysql_data_seek( $res, $row ); }
 596
 597         /**
 598          * Get the last error number
 599          * See mysql_errno()
 600          */
 601         function lastErrno() {
 602                 if ( $this->mConn ) {
 603                         return mysql_errno( $this->mConn );
 604                 } else {
 605                         return mysql_errno();
 606                 }
 607         }
 608
 609         /**
 610          * Get a description of the last error
 611          * See mysql_error() for more details
 612          */
 613         function lastError() {
 614                 if ( $this->mConn ) {
 615                         # Even if it's non-zero, it can still be invalid
 616                         wfSuppressWarnings();
 617                         $error = mysql_error( $this->mConn );
 618                         if ( !$error ) {
 619                                 $error = mysql_error();
 620                         }
 621                         wfRestoreWarnings();
 622                 } else {
 623                         $error = mysql_error();
 624                 }
 625                 if( $error ) {
 626                         $error .= ' (' . $this->mServer . ')';
 627                 }
 628                 return $error;
 629         }
 630         /**
 631          * Get the number of rows affected by the last write query
 632          * See mysql_affected_rows() for more details
 633          */
 634         function affectedRows() { return mysql_affected_rows( $this->mConn ); }
 635         /**#@-*/ // end of template : @param $result
 636
 637         /**
 638          * Simple UPDATE wrapper
 639          * Usually aborts on failure
 640          * If errors are explicitly ignored, returns success
 641          *
 642          * This function exists for historical reasons, Database::update() has a more standard
 643          * calling convention and feature set
 644          */
 645         function set( $table, $var, $value, $cond, $fname = 'Database::set' )
 646         {
 647                 $table = $this->tableName( $table );
 648                 $sql = "UPDATE $table SET $var = '" .
 649                   $this->strencode( $value ) . "' WHERE ($cond)";
 650                 return (bool)$this->query( $sql, DB_MASTER, $fname );
 651         }
 652
 653         /**
 654          * Simple SELECT wrapper, returns a single field, input must be encoded
 655          * Usually aborts on failure
 656          * If errors are explicitly ignored, returns FALSE on failure
 657          */
 658         function selectField( $table, $var, $cond='', $fname = 'Database::selectField', $options = array() ) {
 659                 if ( !is_array( $options ) ) {
 660                         $options = array( $options );
 661                 }
 662                 $options['LIMIT'] = 1;
 663
 664                 $res = $this->select( $table, $var, $cond, $fname, $options );
 665                 if ( $res === false || !$this->numRows( $res ) ) {
 666                         return false;
 667                 }
 668                 $row = $this->fetchRow( $res );
 669                 if ( $row !== false ) {
 670                         $this->freeResult( $res );
 671                         return $row[0];
 672                 } else {
 673                         return false;
 674                 }
 675         }
 676
 677         /**
 678          * Returns an optional USE INDEX clause to go after the table, and a
 679          * string to go at the end of the query
 680          *
 681          * @access private
 682          *
 683          * @param array $options an associative array of options to be turned into
 684          *              an SQL query, valid keys are listed in the function.
 685          * @return array
 686          */
 687         function makeSelectOptions( $options ) {
 688                 $tailOpts = '';
 689
 690                 if ( isset( $options['GROUP BY'] ) ) {
 691                         $tailOpts .= " GROUP BY {$options['GROUP BY']}";
 692                 }
 693                 if ( isset( $options['ORDER BY'] ) ) {
 694                         $tailOpts .= " ORDER BY {$options['ORDER BY']}";
 695                 }
 696
 697                 if ( is_numeric( array_search( 'FOR UPDATE', $options ) ) ) {
 698                         $tailOpts .= ' FOR UPDATE';
 699                 }
 700
 701                 if ( is_numeric( array_search( 'LOCK IN SHARE MODE', $options ) ) ) {
 702                         $tailOpts .= ' LOCK IN SHARE MODE';
 703                 }
 704
 705                 if ( isset( $options['USE INDEX'] ) ) {
 706                         $useIndex = $this->useIndexClause( $options['USE INDEX'] );
 707                 } else {
 708                         $useIndex = '';
 709                 }
 710                 return array( $useIndex, $tailOpts );
 711         }
 712
 713         /**
 714          * SELECT wrapper
 715          */
 716         function select( $table, $vars, $conds='', $fname = 'Database::select', $options = array() )
 717         {
 718                 if( is_array( $vars ) ) {
 719                         $vars = implode( ',', $vars );
 720                 }
 721                 if( !is_array( $options ) ) {
 722                         $options = array( $options );
 723                 }
 724                 if( is_array( $table ) ) {
 725                         $from = ' FROM ' . implode( ',', array_map( array( &$this, 'tableName' ), $table ) );
 726                 } elseif ($table!='') {
 727                         $from = ' FROM ' .$this->tableName( $table );
 728                 } else {
 729                         $from = '';
 730                 }
 731
 732                 list( $useIndex, $tailOpts ) = $this->makeSelectOptions( $options );
 733
 734                 if( !empty( $conds ) ) {
 735                         if ( is_array( $conds ) ) {
 736                                 $conds = $this->makeList( $conds, LIST_AND );
 737                         }
 738                         $sql = "SELECT $vars $from $useIndex WHERE $conds $tailOpts";
 739                 } else {
 740                         $sql = "SELECT $vars $from $useIndex $tailOpts";
 741                 }
 742                 if (isset($options['LIMIT'])) {
 743                         $sql = $this->limitResult($sql, $options['LIMIT'], isset($options['OFFSET']) ? $options['OFFSET'] : false);
 744                 }
 745                 return $this->query( $sql, $fname );
 746         }
 747
 748         /**
 749          * Single row SELECT wrapper
 750          * Aborts or returns FALSE on error
 751          *
 752          * $vars: the selected variables
 753          * $conds: a condition map, terms are ANDed together.
 754          *   Items with numeric keys are taken to be literal conditions
 755          * Takes an array of selected variables, and a condition map, which is ANDed
 756          * e.g: selectRow( "page", array( "page_id" ), array( "page_namespace" =>
 757          * NS_MAIN, "page_title" => "Astronomy" ) )   would return an object where
 758          * $obj- >page_id is the ID of the Astronomy article
 759          *
 760          * @todo migrate documentation to phpdocumentor format
 761          */
 762         function selectRow( $table, $vars, $conds, $fname = 'Database::selectRow', $options = array() ) {
 763                 $options['LIMIT'] = 1;
 764                 $res = $this->select( $table, $vars, $conds, $fname, $options );
 765                 if ( $res === false )
 766                         return false;
 767                 if ( !$this->numRows($res) ) {
 768                         $this->freeResult($res);
 769                         return false;
 770                 }
 771                 $obj = $this->fetchObject( $res );
 772                 $this->freeResult( $res );
 773                 return $obj;
 774
 775         }
 776
 777         /**
 778          * Removes most variables from an SQL query and replaces them with X or N for numbers.
 779          * It's only slightly flawed. Don't use for anything important.
 780          *
 781          * @param string $sql A SQL Query
 782          * @static
 783          */
 784         function generalizeSQL( $sql ) {
 785                 # This does the same as the regexp below would do, but in such a way
 786                 # as to avoid crashing php on some large strings.
 787                 # $sql = preg_replace ( "/'([^\\\\']|\\\\.)*'|\"([^\\\\\"]|\\\\.)*\"/", "'X'", $sql);
 788
 789                 $sql = str_replace ( "\\\\", '', $sql);
 790                 $sql = str_replace ( "\\'", '', $sql);
 791                 $sql = str_replace ( "\\\"", '', $sql);
 792                 $sql = preg_replace ("/'.*'/s", "'X'", $sql);
 793                 $sql = preg_replace ('/".*"/s', "'X'", $sql);
 794
 795                 # All newlines, tabs, etc replaced by single space
 796                 $sql = preg_replace ( "/\s+/", ' ', $sql);
 797
 798                 # All numbers => N
 799                 $sql = preg_replace ('/-?[0-9]+/s', 'N', $sql);
 800
 801                 return $sql;
 802         }
 803
 804         /**
 805          * Determines whether a field exists in a table
 806          * Usually aborts on failure
 807          * If errors are explicitly ignored, returns NULL on failure
 808          */
 809         function fieldExists( $table, $field, $fname = 'Database::fieldExists' ) {
 810                 $table = $this->tableName( $table );
 811                 $res = $this->query( 'DESCRIBE '.$table, DB_SLAVE, $fname );
 812                 if ( !$res ) {
 813                         return NULL;
 814                 }
 815
 816                 $found = false;
 817
 818                 while ( $row = $this->fetchObject( $res ) ) {
 819                         if ( $row->Field == $field ) {
 820                                 $found = true;
 821                                 break;
 822                         }
 823                 }
 824                 return $found;
 825         }
 826
 827         /**
 828          * Determines whether an index exists
 829          * Usually aborts on failure
 830          * If errors are explicitly ignored, returns NULL on failure
 831          */
 832         function indexExists( $table, $index, $fname = 'Database::indexExists' ) {
 833                 $info = $this->indexInfo( $table, $index, $fname );
 834                 if ( is_null( $info ) ) {
 835                         return NULL;
 836                 } else {
 837                         return $info !== false;
 838                 }
 839         }
 840
 841
 842         /**
 843          * Get information about an index into an object
 844          * Returns false if the index does not exist
 845          */
 846         function indexInfo( $table, $index, $fname = 'Database::indexInfo' ) {
 847                 # SHOW INDEX works in MySQL 3.23.58, but SHOW INDEXES does not.
 848                 # SHOW INDEX should work for 3.x and up:
 849                 # http://dev.mysql.com/doc/mysql/en/SHOW_INDEX.html
 850                 $table = $this->tableName( $table );
 851                 $sql = 'SHOW INDEX FROM '.$table;
 852                 $res = $this->query( $sql, $fname );
 853                 if ( !$res ) {
 854                         return NULL;
 855                 }
 856
 857                 while ( $row = $this->fetchObject( $res ) ) {
 858                         if ( $row->Key_name == $index ) {
 859                                 return $row;
 860                         }
 861                 }
 862                 return false;
 863         }
 864
 865         /**
 866          * Query whether a given table exists
 867          */
 868         function tableExists( $table ) {
 869                 $table = $this->tableName( $table );
 870                 $old = $this->ignoreErrors( true );
 871                 $res = $this->query( "SELECT 1 FROM $table LIMIT 1" );
 872                 $this->ignoreErrors( $old );
 873                 if( $res ) {
 874                         $this->freeResult( $res );
 875                         return true;
 876                 } else {
 877                         return false;
 878                 }
 879         }
 880
 881         /**
 882          * mysql_fetch_field() wrapper
 883          * Returns false if the field doesn't exist
 884          *
 885          * @param $table
 886          * @param $field
 887          */
 888         function fieldInfo( $table, $field ) {
 889                 $table = $this->tableName( $table );
 890                 $res = $this->query( "SELECT * FROM $table LIMIT 1" );
 891                 $n = mysql_num_fields( $res );
 892                 for( $i = 0; $i < $n; $i++ ) {
 893                         $meta = mysql_fetch_field( $res, $i );
 894                         if( $field == $meta->name ) {
 895                                 return $meta;
 896                         }
 897                 }
 898                 return false;
 899         }
 900
 901         /**
 902          * mysql_field_type() wrapper
 903          */
 904         function fieldType( $res, $index ) {
 905                 return mysql_field_type( $res, $index );
 906         }
 907
 908         /**
 909          * Determines if a given index is unique
 910          */
 911         function indexUnique( $table, $index ) {
 912                 $indexInfo = $this->indexInfo( $table, $index );
 913                 if ( !$indexInfo ) {
 914                         return NULL;
 915                 }
 916                 return !$indexInfo->Non_unique;
 917         }
 918
 919         /**
 920          * INSERT wrapper, inserts an array into a table
 921          *
 922          * $a may be a single associative array, or an array of these with numeric keys, for
 923          * multi-row insert.
 924          *
 925          * Usually aborts on failure
 926          * If errors are explicitly ignored, returns success
 927          */
 928         function insert( $table, $a, $fname = 'Database::insert', $options = array() ) {
 929                 # No rows to insert, easy just return now
 930                 if ( !count( $a ) ) {
 931                         return true;
 932                 }
 933
 934                 $table = $this->tableName( $table );
 935                 if ( !is_array( $options ) ) {
 936                         $options = array( $options );
 937                 }
 938                 if ( isset( $a[0] ) && is_array( $a[0] ) ) {
 939                         $multi = true;
 940                         $keys = array_keys( $a[0] );
 941                 } else {
 942                         $multi = false;
 943                         $keys = array_keys( $a );
 944                 }
 945
 946                 $sql = 'INSERT ' . implode( ' ', $options ) .
 947                         " INTO $table (" . implode( ',', $keys ) . ') VALUES ';
 948
 949                 if ( $multi ) {
 950                         $first = true;
 951                         foreach ( $a as $row ) {
 952                                 if ( $first ) {
 953                                         $first = false;
 954                                 } else {
 955                                         $sql .= ',';
 956                                 }
 957                                 $sql .= '(' . $this->makeList( $row ) . ')';
 958                         }
 959                 } else {
 960                         $sql .= '(' . $this->makeList( $a ) . ')';
 961                 }
 962                 return (bool)$this->query( $sql, $fname );
 963         }
 964
 965         /**
 966          * Make UPDATE options for the Database::update function
 967          *
 968          * @access private
 969          * @param array $options The options passed to Database::update
 970          * @return string
 971          */
 972         function makeUpdateOptions( $options ) {
 973                 if( !is_array( $options ) ) {
 974                         wfDebugDieBacktrace( 'makeUpdateOptions given non-array' );
 975                 }
 976                 $opts = array();
 977                 if ( in_array( 'LOW_PRIORITY', $options ) )
 978                         $opts[] = $this->lowPriorityOption();
 979                 if ( in_array( 'IGNORE', $options ) )
 980                         $opts[] = 'IGNORE';
 981                 return implode(' ', $opts);
 982         }
 983
 984         /**
 985          * UPDATE wrapper, takes a condition array and a SET array
 986          *
 987          * @param string $table  The table to UPDATE
 988          * @param array  $values An array of values to SET
 989          * @param array  $conds  An array of conditions (WHERE)
 990          * @param string $fname  The Class::Function calling this function
 991          *                       (for the log)
 992          * @param array  $options An array of UPDATE options, can be one or
 993          *                        more of IGNORE, LOW_PRIORITY
 994          */
 995         function update( $table, $values, $conds, $fname = 'Database::update', $options = array() ) {
 996                 $table = $this->tableName( $table );
 997                 $opts = $this->makeUpdateOptions( $options );
 998                 $sql = "UPDATE $opts $table SET " . $this->makeList( $values, LIST_SET );
 999                 if ( $conds != '*' ) {
1000                         $sql .= " WHERE " . $this->makeList( $conds, LIST_AND );
1001                 }
1002                 $this->query( $sql, $fname );
1003         }
1004
1005         /**
1006          * Makes a wfStrencoded list from an array
1007          * $mode: LIST_COMMA         - comma separated, no field names
1008          *        LIST_AND           - ANDed WHERE clause (without the WHERE)
1009          *        LIST_SET           - comma separated with field names, like a SET clause
1010          *        LIST_NAMES         - comma separated field names
1011          */
1012         function makeList( $a, $mode = LIST_COMMA ) {
1013                 if ( !is_array( $a ) ) {
1014                         wfDebugDieBacktrace( 'Database::makeList called with incorrect parameters' );
1015                 }
1016
1017                 $first = true;
1018                 $list = '';
1019                 foreach ( $a as $field => $value ) {
1020                         if ( !$first ) {
1021                                 if ( $mode == LIST_AND ) {
1022                                         $list .= ' AND ';
1023                                 } else {
1024                                         $list .= ',';
1025                                 }
1026                         } else {
1027                                 $first = false;
1028                         }
1029                         if ( $mode == LIST_AND && is_numeric( $field ) ) {
1030                                 $list .= "($value)";
1031                         } elseif ( $mode == LIST_AND && is_array ($value) ) {
1032                                 $list .= $field." IN (".$this->makeList($value).") ";
1033                         } else {
1034                                 if ( $mode == LIST_AND || $mode == LIST_SET ) {
1035                                         $list .= "$field = ";
1036                                 }
1037                                 $list .= $mode == LIST_NAMES ? $value : $this->addQuotes( $value );
1038                         }
1039                 }
1040                 return $list;
1041         }
1042
1043         /**
1044          * Change the current database
1045          */
1046         function selectDB( $db ) {
1047                 $this->mDBname = $db;
1048                 return mysql_select_db( $db, $this->mConn );
1049         }
1050
1051         /**
1052          * Starts a timer which will kill the DB thread after $timeout seconds
1053          */
1054         function startTimer( $timeout ) {
1055                 global $IP;
1056                 if( function_exists( 'mysql_thread_id' ) ) {
1057                         # This will kill the query if it's still running after $timeout seconds.
1058                         $tid = mysql_thread_id( $this->mConn );
1059                         exec( "php $IP/includes/killthread.php $timeout $tid &>/dev/null &" );
1060                 }
1061         }
1062
1063         /**
1064          * Stop a timer started by startTimer()
1065          * Currently unimplemented.
1066          *
1067          */
1068         function stopTimer() { }
1069
1070         /**
1071          * Format a table name ready for use in constructing an SQL query
1072          *
1073          * This does two important things: it quotes table names which as necessary,
1074          * and it adds a table prefix if there is one.
1075          *
1076          * All functions of this object which require a table name call this function
1077          * themselves. Pass the canonical name to such functions. This is only needed
1078          * when calling query() directly.
1079          *
1080          * @param string $name database table name
1081          */
1082         function tableName( $name ) {
1083                 global $wgSharedDB;
1084                 # Skip quoted literals
1085                 if ( $name{0} != '`' ) {
1086                         if ( $this->mTablePrefix !== '' &&  strpos( '.', $name ) === false ) {
1087                                 $name = "{$this->mTablePrefix}$name";
1088                         }
1089                         if ( isset( $wgSharedDB ) && "{$this->mTablePrefix}user" == $name ) {
1090                                 $name = "`$wgSharedDB`.`$name`";
1091                         } else {
1092                                 # Standard quoting
1093                                 $name = "`$name`";
1094                         }
1095                 }
1096                 return $name;
1097         }
1098
1099         /**
1100          * Fetch a number of table names into an array
1101          * This is handy when you need to construct SQL for joins
1102          *
1103          * Example:
1104          * extract($dbr->tableNames('user','watchlist'));
1105          * $sql = "SELECT wl_namespace,wl_title FROM $watchlist,$user
1106          *         WHERE wl_user=user_id AND wl_user=$nameWithQuotes";
1107          */
1108         function tableNames() {
1109                 $inArray = func_get_args();
1110                 $retVal = array();
1111                 foreach ( $inArray as $name ) {
1112                         $retVal[$name] = $this->tableName( $name );
1113                 }
1114                 return $retVal;
1115         }
1116
1117         /**
1118          * Wrapper for addslashes()
1119          * @param string $s String to be slashed.
1120          * @return string slashed string.
1121          */
1122         function strencode( $s ) {
1123                 return addslashes( $s );
1124         }
1125
1126         /**
1127          * If it's a string, adds quotes and backslashes
1128          * Otherwise returns as-is
1129          */
1130         function addQuotes( $s ) {
1131                 if ( is_null( $s ) ) {
1132                         return 'NULL';
1133                 } else {
1134                         # This will also quote numeric values. This should be harmless,
1135                         # and protects against weird problems that occur when they really
1136                         # _are_ strings such as article titles and string->number->string
1137                         # conversion is not 1:1.
1138                         return "'" . $this->strencode( $s ) . "'";
1139                 }
1140         }
1141
1142         /**
1143          * Escape string for safe LIKE usage
1144          */
1145         function escapeLike( $s ) {
1146                 $s=$this->strencode( $s );
1147                 $s=str_replace(array('%','_'),array('\%','\_'),$s);
1148                 return $s;
1149         }
1150
1151         /**
1152          * Returns an appropriately quoted sequence value for inserting a new row.
1153          * MySQL has autoincrement fields, so this is just NULL. But the PostgreSQL
1154          * subclass will return an integer, and save the value for insertId()
1155          */
1156         function nextSequenceValue( $seqName ) {
1157                 return NULL;
1158         }
1159
1160         /**
1161          * USE INDEX clause
1162          * PostgreSQL doesn't have them and returns ""
1163          */
1164         function useIndexClause( $index ) {
1165                 global $wgDBmysql4;
1166                 return $wgDBmysql4
1167                         ? "FORCE INDEX ($index)"
1168                         : "USE INDEX ($index)";
1169         }
1170
1171         /**
1172          * REPLACE query wrapper
1173          * PostgreSQL simulates this with a DELETE followed by INSERT
1174          * $row is the row to insert, an associative array
1175          * $uniqueIndexes is an array of indexes. Each element may be either a
1176          * field name or an array of field names
1177          *
1178          * It may be more efficient to leave off unique indexes which are unlikely to collide.
1179          * However if you do this, you run the risk of encountering errors which wouldn't have
1180          * occurred in MySQL
1181          *
1182          * @todo migrate comment to phodocumentor format
1183          */
1184         function replace( $table, $uniqueIndexes, $rows, $fname = 'Database::replace' ) {
1185                 $table = $this->tableName( $table );
1186
1187                 # Single row case
1188                 if ( !is_array( reset( $rows ) ) ) {
1189                         $rows = array( $rows );
1190                 }
1191
1192                 $sql = "REPLACE INTO $table (" . implode( ',', array_keys( $rows[0] ) ) .') VALUES ';
1193                 $first = true;
1194                 foreach ( $rows as $row ) {
1195                         if ( $first ) {
1196                                 $first = false;
1197                         } else {
1198                                 $sql .= ',';
1199                         }
1200                         $sql .= '(' . $this->makeList( $row ) . ')';
1201                 }
1202                 return $this->query( $sql, $fname );
1203         }
1204
1205         /**
1206          * DELETE where the condition is a join
1207          * MySQL does this with a multi-table DELETE syntax, PostgreSQL does it with sub-selects
1208          *
1209          * For safety, an empty $conds will not delete everything. If you want to delete all rows where the
1210          * join condition matches, set $conds='*'
1211          *
1212          * DO NOT put the join condition in $conds
1213          *
1214          * @param string $delTable The table to delete from.
1215          * @param string $joinTable The other table.
1216          * @param string $delVar The variable to join on, in the first table.
1217          * @param string $joinVar The variable to join on, in the second table.
1218          * @param array $conds Condition array of field names mapped to variables, ANDed together in the WHERE clause
1219          */
1220         function deleteJoin( $delTable, $joinTable, $delVar, $joinVar, $conds, $fname = 'Database::deleteJoin' ) {
1221                 if ( !$conds ) {
1222                         wfDebugDieBacktrace( 'Database::deleteJoin() called with empty $conds' );
1223                 }
1224
1225                 $delTable = $this->tableName( $delTable );
1226                 $joinTable = $this->tableName( $joinTable );
1227                 $sql = "DELETE $delTable FROM $delTable, $joinTable WHERE $delVar=$joinVar ";
1228                 if ( $conds != '*' ) {
1229                         $sql .= ' AND ' . $this->makeList( $conds, LIST_AND );
1230                 }
1231
1232                 return $this->query( $sql, $fname );
1233         }
1234
1235         /**
1236          * Returns the size of a text field, or -1 for "unlimited"
1237          */
1238         function textFieldSize( $table, $field ) {
1239                 $table = $this->tableName( $table );
1240                 $sql = "SHOW COLUMNS FROM $table LIKE \"$field\";";
1241                 $res = $this->query( $sql, 'Database::textFieldSize' );
1242                 $row = $this->fetchObject( $res );
1243                 $this->freeResult( $res );
1244
1245                 if ( preg_match( "/\((.*)\)/", $row->Type, $m ) ) {
1246                         $size = $m[1];
1247                 } else {
1248                         $size = -1;
1249                 }
1250                 return $size;
1251         }
1252
1253         /**
1254          * @return string Returns the text of the low priority option if it is supported, or a blank string otherwise
1255          */
1256         function lowPriorityOption() {
1257                 return 'LOW_PRIORITY';
1258         }
1259
1260         /**
1261          * DELETE query wrapper
1262          *
1263          * Use $conds == "*" to delete all rows
1264          */
1265         function delete( $table, $conds, $fname = 'Database::delete' ) {
1266                 if ( !$conds ) {
1267                         wfDebugDieBacktrace( 'Database::delete() called with no conditions' );
1268                 }
1269                 $table = $this->tableName( $table );
1270                 $sql = "DELETE FROM $table";
1271                 if ( $conds != '*' ) {
1272                         $sql .= ' WHERE ' . $this->makeList( $conds, LIST_AND );
1273                 }
1274                 return $this->query( $sql, $fname );
1275         }
1276
1277         /**
1278          * INSERT SELECT wrapper
1279          * $varMap must be an associative array of the form array( 'dest1' => 'source1', ...)
1280          * Source items may be literals rather than field names, but strings should be quoted with Database::addQuotes()
1281          * $conds may be "*" to copy the whole table
1282          * srcTable may be an array of tables.
1283          */
1284         function insertSelect( $destTable, $srcTable, $varMap, $conds, $fname = 'Database::insertSelect' ) {
1285                 $destTable = $this->tableName( $destTable );
1286                 if( is_array( $srcTable ) ) {
1287                         $srcTable =  implode( ',', array_map( array( &$this, 'tableName' ), $srcTable ) );
1288                 } else {
1289                         $srcTable = $this->tableName( $srcTable );
1290                 }
1291                 $sql = "INSERT INTO $destTable (" . implode( ',', array_keys( $varMap ) ) . ')' .
1292                         ' SELECT ' . implode( ',', $varMap ) .
1293                         " FROM $srcTable";
1294                 if ( $conds != '*' ) {
1295                         $sql .= ' WHERE ' . $this->makeList( $conds, LIST_AND );
1296                 }
1297                 return $this->query( $sql, $fname );
1298         }
1299
1300         /**
1301          * Construct a LIMIT query with optional offset
1302          * This is used for query pages
1303          * $sql string SQL query we will append the limit too
1304          * $limit integer the SQL limit
1305          * $offset integer the SQL offset (default false)
1306          */
1307         function limitResult($sql, $limit, $offset=false) {
1308                 return " $sql LIMIT ".((is_numeric($offset) && $offset != 0)?"{$offset},":"")."{$limit} ";
1309         }
1310         function limitResultForUpdate($sql, $num) {
1311                 return $this->limitResult($sql, $num, 0);
1312         }
1313
1314         /**
1315          * Returns an SQL expression for a simple conditional.
1316          * Uses IF on MySQL.
1317          *
1318          * @param string $cond SQL expression which will result in a boolean value
1319          * @param string $trueVal SQL expression to return if true
1320          * @param string $falseVal SQL expression to return if false
1321          * @return string SQL fragment
1322          */
1323         function conditional( $cond, $trueVal, $falseVal ) {
1324                 return " IF($cond, $trueVal, $falseVal) ";
1325         }
1326
1327         /**
1328          * Determines if the last failure was due to a deadlock
1329          */
1330         function wasDeadlock() {
1331                 return $this->lastErrno() == 1213;
1332         }
1333
1334         /**
1335          * Perform a deadlock-prone transaction.
1336          *
1337          * This function invokes a callback function to perform a set of write
1338          * queries. If a deadlock occurs during the processing, the transaction
1339          * will be rolled back and the callback function will be called again.
1340          *
1341          * Usage:
1342          *   $dbw->deadlockLoop( callback, ... );
1343          *
1344          * Extra arguments are passed through to the specified callback function.
1345          *
1346          * Returns whatever the callback function returned on its successful,
1347          * iteration, or false on error, for example if the retry limit was
1348          * reached.
1349          */
1350         function deadlockLoop() {
1351                 $myFname = 'Database::deadlockLoop';
1352
1353                 $this->begin();
1354                 $args = func_get_args();
1355                 $function = array_shift( $args );
1356                 $oldIgnore = $this->ignoreErrors( true );
1357                 $tries = DEADLOCK_TRIES;
1358                 if ( is_array( $function ) ) {
1359                         $fname = $function[0];
1360                 } else {
1361                         $fname = $function;
1362                 }
1363                 do {
1364                         $retVal = call_user_func_array( $function, $args );
1365                         $error = $this->lastError();
1366                         $errno = $this->lastErrno();
1367                         $sql = $this->lastQuery();
1368
1369                         if ( $errno ) {
1370                                 if ( $this->wasDeadlock() ) {
1371                                         # Retry
1372                                         usleep( mt_rand( DEADLOCK_DELAY_MIN, DEADLOCK_DELAY_MAX ) );
1373                                 } else {
1374                                         $this->reportQueryError( $error, $errno, $sql, $fname );
1375                                 }
1376                         }
1377                 } while( $this->wasDeadlock() && --$tries > 0 );
1378                 $this->ignoreErrors( $oldIgnore );
1379                 if ( $tries <= 0 ) {
1380                         $this->query( 'ROLLBACK', $myFname );
1381                         $this->reportQueryError( $error, $errno, $sql, $fname );
1382                         return false;
1383                 } else {
1384                         $this->query( 'COMMIT', $myFname );
1385                         return $retVal;
1386                 }
1387         }
1388
1389         /**
1390          * Do a SELECT MASTER_POS_WAIT()
1391          *
1392          * @param string $file the binlog file
1393          * @param string $pos the binlog position
1394          * @param integer $timeout the maximum number of seconds to wait for synchronisation
1395          */
1396         function masterPosWait( $file, $pos, $timeout ) {
1397                 $fname = 'Database::masterPosWait';
1398                 wfProfileIn( $fname );
1399
1400
1401                 # Commit any open transactions
1402                 $this->immediateCommit();
1403
1404                 # Call doQuery() directly, to avoid opening a transaction if DBO_TRX is set
1405                 $encFile = $this->strencode( $file );
1406                 $sql = "SELECT MASTER_POS_WAIT('$encFile', $pos, $timeout)";
1407                 $res = $this->doQuery( $sql );
1408                 if ( $res && $row = $this->fetchRow( $res ) ) {
1409                         $this->freeResult( $res );
1410                         wfProfileOut( $fname );
1411                         return $row[0];
1412                 } else {
1413                         wfProfileOut( $fname );
1414                         return false;
1415                 }
1416         }
1417
1418         /**
1419          * Get the position of the master from SHOW SLAVE STATUS
1420          */
1421         function getSlavePos() {
1422                 $res = $this->query( 'SHOW SLAVE STATUS', 'Database::getSlavePos' );
1423                 $row = $this->fetchObject( $res );
1424                 if ( $row ) {
1425                         return array( $row->Master_Log_File, $row->Read_Master_Log_Pos );
1426                 } else {
1427                         return array( false, false );
1428                 }
1429         }
1430
1431         /**
1432          * Get the position of the master from SHOW MASTER STATUS
1433          */
1434         function getMasterPos() {
1435                 $res = $this->query( 'SHOW MASTER STATUS', 'Database::getMasterPos' );
1436                 $row = $this->fetchObject( $res );
1437                 if ( $row ) {
1438                         return array( $row->File, $row->Position );
1439                 } else {
1440                         return array( false, false );
1441                 }
1442         }
1443
1444         /**
1445          * Begin a transaction, or if a transaction has already started, continue it
1446          */
1447         function begin( $fname = 'Database::begin' ) {
1448                 if ( !$this->mTrxLevel ) {
1449                         $this->immediateBegin( $fname );
1450                 } else {
1451                         $this->mTrxLevel++;
1452                 }
1453         }
1454
1455         /**
1456          * End a transaction, or decrement the nest level if transactions are nested
1457          */
1458         function commit( $fname = 'Database::commit' ) {
1459                 if ( $this->mTrxLevel ) {
1460                         $this->mTrxLevel--;
1461                 }
1462                 if ( !$this->mTrxLevel ) {
1463                         $this->immediateCommit( $fname );
1464                 }
1465         }
1466
1467         /**
1468          * Rollback a transaction
1469          */
1470         function rollback( $fname = 'Database::rollback' ) {
1471                 $this->query( 'ROLLBACK', $fname );
1472                 $this->mTrxLevel = 0;
1473         }
1474
1475         /**
1476          * Begin a transaction, committing any previously open transaction
1477          */
1478         function immediateBegin( $fname = 'Database::immediateBegin' ) {
1479                 $this->query( 'BEGIN', $fname );
1480                 $this->mTrxLevel = 1;
1481         }
1482
1483         /**
1484          * Commit transaction, if one is open
1485          */
1486         function immediateCommit( $fname = 'Database::immediateCommit' ) {
1487                 $this->query( 'COMMIT', $fname );
1488                 $this->mTrxLevel = 0;
1489         }
1490
1491         /**
1492          * Return MW-style timestamp used for MySQL schema
1493          */
1494         function timestamp( $ts=0 ) {
1495                 return wfTimestamp(TS_MW,$ts);
1496         }
1497
1498         /**
1499          * Local database timestamp format or null
1500          */
1501         function timestampOrNull( $ts = null ) {
1502                 if( is_null( $ts ) ) {
1503                         return null;
1504                 } else {
1505                         return $this->timestamp( $ts );
1506                 }
1507         }
1508
1509         /**
1510          * @todo document
1511          */
1512         function resultObject( &$result ) {
1513                 if( empty( $result ) ) {
1514                         return NULL;
1515                 } else {
1516                         return new ResultWrapper( $this, $result );
1517                 }
1518         }
1519
1520         /**
1521          * Return aggregated value alias
1522          */
1523         function aggregateValue ($valuedata,$valuename='value') {
1524                 return $valuename;
1525         }
1526
1527         /**
1528          * @return string wikitext of a link to the server software's web site
1529          */
1530         function getSoftwareLink() {
1531                 return "[http://www.mysql.com/ MySQL]";
1532         }
1533
1534         /**
1535          * @return string Version information from the database
1536          */
1537         function getServerVersion() {
1538                 return mysql_get_server_info();
1539         }
1540
1541         /**
1542          * Ping the server and try to reconnect if it there is no connection
1543          */
1544         function ping() {
1545                 if( function_exists( 'mysql_ping' ) ) {
1546                         return mysql_ping( $this->mConn );
1547                 } else {
1548                         wfDebug( "Tried to call mysql_ping but this is ancient PHP version. Faking it!\n" );
1549                         return true;
1550                 }
1551         }
1552
1553         /**
1554          * Get slave lag.
1555          * At the moment, this will only work if the DB user has the PROCESS privilege
1556          */
1557         function getLag() {
1558                 $res = $this->query( 'SHOW PROCESSLIST' );
1559                 # Find slave SQL thread. Assumed to be the second one running, which is a bit
1560                 # dubious, but unfortunately there's no easy rigorous way
1561                 $slaveThreads = 0;
1562                 while ( $row = $this->fetchObject( $res ) ) {
1563                         if ( $row->User == 'system user' ) {
1564                                 if ( ++$slaveThreads == 2 ) {
1565                                         # This is it, return the time
1566                                         return $row->Time;
1567                                 }
1568                         }
1569                 }
1570                 return false;
1571         }
1572
1573         /**
1574          * Get status information from SHOW STATUS in an associative array
1575          */
1576         function getStatus() {
1577                 $res = $this->query( 'SHOW STATUS' );
1578                 $status = array();
1579                 while ( $row = $this->fetchObject( $res ) ) {
1580                         $status[$row->Variable_name] = $row->Value;
1581                 }
1582                 return $status;
1583         }
1584
1585         /**
1586          * Return the maximum number of items allowed in a list, or 0 for unlimited.
1587          */
1588         function maxListLen() {
1589                 return 0;
1590         }
1591
1592         function encodeBlob($b) {
1593                 return $b;
1594         }
1595
1596         function notNullTimestamp() {
1597                 return "!= 0";
1598         }
1599         function isNullTimestamp() {
1600                 return "= '0'";
1601         }
1602 }
1603
1604 /**
1605  * Database abstraction object for mySQL
1606  * Inherit all methods and properties of Database::Database()
1607  *
1608  * @package MediaWiki
1609  * @see Database
1610  */
1611 class DatabaseMysql extends Database {
1612         # Inherit all
1613 }
1614
1615
1616 /**
1617  * Result wrapper for grabbing data queried by someone else
1618  *
1619  * @package MediaWiki
1620  */
1621 class ResultWrapper {
1622         var $db, $result;
1623
1624         /**
1625          * @todo document
1626          */
1627         function ResultWrapper( $database, $result ) {
1628                 $this->db =& $database;
1629                 $this->result =& $result;
1630         }
1631
1632         /**
1633          * @todo document
1634          */
1635         function numRows() {
1636                 return $this->db->numRows( $this->result );
1637         }
1638
1639         /**
1640          * @todo document
1641          */
1642         function fetchObject() {
1643                 return $this->db->fetchObject( $this->result );
1644         }
1645
1646         /**
1647          * @todo document
1648          */
1649         function &fetchRow() {
1650                 return $this->db->fetchRow( $this->result );
1651         }
1652
1653         /**
1654          * @todo document
1655          */
1656         function free() {
1657                 $this->db->freeResult( $this->result );
1658                 unset( $this->result );
1659                 unset( $this->db );
1660         }
1661
1662         function seek( $row ) {
1663                 $this->db->dataSeek( $this->result, $row );
1664         }
1665 }
1666
1667 #------------------------------------------------------------------------------
1668 # Global functions
1669 #------------------------------------------------------------------------------
1670
1671 /**
1672  * Standard fail function, called by default when a connection cannot be
1673  * established.
1674  * Displays the file cache if possible
1675  */
1676 function wfEmergencyAbort( &$conn, $error ) {
1677         global $wgTitle, $wgUseFileCache, $title, $wgInputEncoding, $wgOutputEncoding;
1678         global $wgSitename, $wgServer, $wgMessageCache;
1679
1680         # I give up, Brion is right. Getting the message cache to work when there is no DB is tricky.
1681         # Hard coding strings instead.
1682
1683         $noconnect = 'Sorry! The wiki is experiencing some technical difficulties, and cannot contact the database server: $1. <br />
1684 $1';
1685         $mainpage = 'Main Page';
1686         $searchdisabled = <<<EOT
1687 <p style="margin: 1.5em 2em 1em">$wgSitename search is disabled for performance reasons. You can search via Google in the meantime.
1688 <span style="font-size: 89%; display: block; margin-left: .2em">Note that their indexes of $wgSitename content may be out of date.</span></p>',
1689 EOT;
1690
1691         $googlesearch = "
1692 <!-- SiteSearch Google -->
1693 <FORM method=GET action=\"http://www.google.com/search\">
1694 <TABLE bgcolor=\"#FFFFFF\"><tr><td>
1695 <A HREF=\"http://www.google.com/\">
1696 <IMG SRC=\"http://www.google.com/logos/Logo_40wht.gif\"
1697 border=\"0\" ALT=\"Google\"></A>
1698 </td>
1699 <td>
1700 <INPUT TYPE=text name=q size=31 maxlength=255 value=\"$1\">
1701 <INPUT type=submit name=btnG VALUE=\"Google Search\">
1702 <font size=-1>
1703 <input type=hidden name=domains value=\"$wgServer\"><br /><input type=radio name=sitesearch value=\"\"> WWW <input type=radio name=sitesearch value=\"$wgServer\" checked> $wgServer <br />
1704 <input type='hidden' name='ie' value='$2'>
1705 <input type='hidden' name='oe' value='$2'>
1706 </font>
1707 </td></tr></TABLE>
1708 </FORM>
1709 <!-- SiteSearch Google -->";
1710         $cachederror = "The following is a cached copy of the requested page, and may not be up to date. ";
1711
1712
1713         if( !headers_sent() ) {
1714                 header( 'HTTP/1.0 500 Internal Server Error' );
1715                 header( 'Content-type: text/html; charset='.$wgOutputEncoding );
1716                 /* Don't cache error pages!  They cause no end of trouble... */
1717                 header( 'Cache-control: none' );
1718                 header( 'Pragma: nocache' );
1719         }
1720
1721         # No database access
1722         $wgMessageCache->disable();
1723
1724         $msg = wfGetSiteNotice();
1725         if($msg == '') {
1726                 $msg = str_replace( '$1', $error, $noconnect );
1727         }
1728         $text = $msg;
1729
1730         if($wgUseFileCache) {
1731                 if($wgTitle) {
1732                         $t =& $wgTitle;
1733                 } else {
1734                         if($title) {
1735                                 $t = Title::newFromURL( $title );
1736                         } elseif (@/**/$_REQUEST['search']) {
1737                                 $search = $_REQUEST['search'];
1738                                 echo $searchdisabled;
1739                                 echo str_replace( array( '$1', '$2' ), array( htmlspecialchars( $search ),
1740                                   $wgInputEncoding ), $googlesearch );
1741                                 wfErrorExit();
1742                         } else {
1743                                 $t = Title::newFromText( $mainpage );
1744                         }
1745                 }
1746
1747                 $cache = new CacheManager( $t );
1748                 if( $cache->isFileCached() ) {
1749                         $msg = '<p style="color: red"><b>'.$msg."<br />\n" .
1750                                 $cachederror . "</b></p>\n";
1751
1752                         $tag = '<div id="article">';
1753                         $text = str_replace(
1754                                 $tag,
1755                                 $tag . $msg,
1756                                 $cache->fetchPageText() );
1757                 }
1758         }
1759
1760         echo $text;
1761         wfErrorExit();
1762 }
1763
1764 ?>