diff options
Diffstat (limited to 'includes/db')
| -rw-r--r-- | includes/db/Database.php | 2699 | ||||
| -rw-r--r-- | includes/db/DatabaseMssql.php | 1029 | ||||
| -rw-r--r-- | includes/db/DatabaseOracle.php | 720 | ||||
| -rw-r--r-- | includes/db/DatabasePostgres.php | 1394 | ||||
| -rw-r--r-- | includes/db/DatabaseSqlite.php | 405 | ||||
| -rw-r--r-- | includes/db/LBFactory.php | 261 | ||||
| -rw-r--r-- | includes/db/LBFactory_Multi.php | 233 | ||||
| -rw-r--r-- | includes/db/LoadBalancer.php | 918 | ||||
| -rw-r--r-- | includes/db/LoadMonitor.php | 121 |
9 files changed, 7780 insertions, 0 deletions
diff --git a/includes/db/Database.php b/includes/db/Database.php new file mode 100644 index 00000000..885ede54 --- /dev/null +++ b/includes/db/Database.php @@ -0,0 +1,2699 @@ +<?php +/** + * @defgroup Database Database + * + * @file + * @ingroup Database + * This file deals with MySQL interface functions + * and query specifics/optimisations + */ + +/** Number of times to re-try an operation in case of deadlock */ +define( 'DEADLOCK_TRIES', 4 ); +/** Minimum time to wait before retry, in microseconds */ +define( 'DEADLOCK_DELAY_MIN', 500000 ); +/** Maximum time to wait before retry */ +define( 'DEADLOCK_DELAY_MAX', 1500000 ); + +/** + * Database abstraction object + * @ingroup Database + */ +class Database { + +#------------------------------------------------------------------------------ +# Variables +#------------------------------------------------------------------------------ + + protected $mLastQuery = ''; + protected $mPHPError = false; + + protected $mServer, $mUser, $mPassword, $mConn = null, $mDBname; + protected $mOpened = false; + + protected $mFailFunction; + protected $mTablePrefix; + protected $mFlags; + protected $mTrxLevel = 0; + protected $mErrorCount = 0; + protected $mLBInfo = array(); + protected $mFakeSlaveLag = null, $mFakeMaster = false; + +#------------------------------------------------------------------------------ +# Accessors +#------------------------------------------------------------------------------ + # These optionally set a variable and return the previous state + + /** + * Fail function, takes a Database as a parameter + * Set to false for default, 1 for ignore errors + */ + function failFunction( $function = NULL ) { + return wfSetVar( $this->mFailFunction, $function ); + } + + /** + * Output page, used for reporting errors + * FALSE means discard output + */ + function setOutputPage( $out ) { + wfDeprecated( __METHOD__ ); + } + + /** + * Boolean, controls output of large amounts of debug information + */ + function debug( $debug = NULL ) { + return wfSetBit( $this->mFlags, DBO_DEBUG, $debug ); + } + + /** + * Turns buffering of SQL result sets on (true) or off (false). + * Default is "on" and it should not be changed without good reasons. + */ + function bufferResults( $buffer = NULL ) { + if ( is_null( $buffer ) ) { + return !(bool)( $this->mFlags & DBO_NOBUFFER ); + } else { + return !wfSetBit( $this->mFlags, DBO_NOBUFFER, !$buffer ); + } + } + + /** + * Turns on (false) or off (true) the automatic generation and sending + * of a "we're sorry, but there has been a database error" page on + * database errors. Default is on (false). When turned off, the + * code should use lastErrno() and lastError() to handle the + * situation as appropriate. + */ + function ignoreErrors( $ignoreErrors = NULL ) { + return wfSetBit( $this->mFlags, DBO_IGNORE, $ignoreErrors ); + } + + /** + * The current depth of nested transactions + * @param $level Integer: , default NULL. + */ + function trxLevel( $level = NULL ) { + return wfSetVar( $this->mTrxLevel, $level ); + } + + /** + * Number of errors logged, only useful when errors are ignored + */ + function errorCount( $count = NULL ) { + return wfSetVar( $this->mErrorCount, $count ); + } + + function tablePrefix( $prefix = null ) { + return wfSetVar( $this->mTablePrefix, $prefix ); + } + + /** + * Properties passed down from the server info array of the load balancer + */ + function getLBInfo( $name = NULL ) { + if ( is_null( $name ) ) { + return $this->mLBInfo; + } else { + if ( array_key_exists( $name, $this->mLBInfo ) ) { + return $this->mLBInfo[$name]; + } else { + return NULL; + } + } + } + + function setLBInfo( $name, $value = NULL ) { + if ( is_null( $value ) ) { + $this->mLBInfo = $name; + } else { + $this->mLBInfo[$name] = $value; + } + } + + /** + * Set lag time in seconds for a fake slave + */ + function setFakeSlaveLag( $lag ) { + $this->mFakeSlaveLag = $lag; + } + + /** + * Make this connection a fake master + */ + function setFakeMaster( $enabled = true ) { + $this->mFakeMaster = $enabled; + } + + /** + * Returns true if this database supports (and uses) cascading deletes + */ + function cascadingDeletes() { + return false; + } + + /** + * Returns true if this database supports (and uses) triggers (e.g. on the page table) + */ + function cleanupTriggers() { + return false; + } + + /** + * Returns true if this database is strict about what can be put into an IP field. + * Specifically, it uses a NULL value instead of an empty string. + */ + function strictIPs() { + return false; + } + + /** + * Returns true if this database uses timestamps rather than integers + */ + function realTimestamps() { + return false; + } + + /** + * Returns true if this database does an implicit sort when doing GROUP BY + */ + function implicitGroupby() { + return true; + } + + /** + * Returns true if this database does an implicit order by when the column has an index + * For example: SELECT page_title FROM page LIMIT 1 + */ + function implicitOrderby() { + return true; + } + + /** + * Returns true if this database can do a native search on IP columns + * e.g. this works as expected: .. WHERE rc_ip = '127.42.12.102/32'; + */ + function searchableIPs() { + return false; + } + + /** + * Returns true if this database can use functional indexes + */ + function functionalIndexes() { + return false; + } + + /**#@+ + * Get function + */ + function lastQuery() { return $this->mLastQuery; } + function isOpen() { return $this->mOpened; } + /**#@-*/ + + function setFlag( $flag ) { + $this->mFlags |= $flag; + } + + function clearFlag( $flag ) { + $this->mFlags &= ~$flag; + } + + function getFlag( $flag ) { + return !!($this->mFlags & $flag); + } + + /** + * General read-only accessor + */ + function getProperty( $name ) { + return $this->$name; + } + + function getWikiID() { + if( $this->mTablePrefix ) { + return "{$this->mDBname}-{$this->mTablePrefix}"; + } else { + return $this->mDBname; + } + } + +#------------------------------------------------------------------------------ +# Other functions +#------------------------------------------------------------------------------ + + /**@{{ + * Constructor. + * @param string $server database server host + * @param string $user database user name + * @param string $password database user password + * @param string $dbname database name + * @param failFunction + * @param $flags + * @param $tablePrefix String: database table prefixes. By default use the prefix gave in LocalSettings.php + */ + function __construct( $server = false, $user = false, $password = false, $dbName = false, + $failFunction = false, $flags = 0, $tablePrefix = 'get from global' ) { + + global $wgOut, $wgDBprefix, $wgCommandLineMode; + # Can't get a reference if it hasn't been set yet + if ( !isset( $wgOut ) ) { + $wgOut = NULL; + } + + $this->mFailFunction = $failFunction; + $this->mFlags = $flags; + + if ( $this->mFlags & DBO_DEFAULT ) { + if ( $wgCommandLineMode ) { + $this->mFlags &= ~DBO_TRX; + } else { + $this->mFlags |= DBO_TRX; + } + } + + /* + // Faster read-only access + if ( wfReadOnly() ) { + $this->mFlags |= DBO_PERSISTENT; + $this->mFlags &= ~DBO_TRX; + }*/ + + /** Get the default table prefix*/ + if ( $tablePrefix == 'get from global' ) { + $this->mTablePrefix = $wgDBprefix; + } else { + $this->mTablePrefix = $tablePrefix; + } + + if ( $server ) { + $this->open( $server, $user, $password, $dbName ); + } + } + + /** + * @static + * @param failFunction + * @param $flags + */ + static function newFromParams( $server, $user, $password, $dbName, $failFunction = false, $flags = 0 ) + { + return new Database( $server, $user, $password, $dbName, $failFunction, $flags ); + } + + /** + * Usually aborts on failure + * If the failFunction is set to a non-zero integer, returns success + */ + function open( $server, $user, $password, $dbName ) { + global $wguname, $wgAllDBsAreLocalhost; + wfProfileIn( __METHOD__ ); + + # Test for missing mysql.so + # First try to load it + if (!@extension_loaded('mysql')) { + @dl('mysql.so'); + } + + # Fail now + # Otherwise we get a suppressed fatal error, which is very hard to track down + if ( !function_exists( 'mysql_connect' ) ) { + throw new DBConnectionError( $this, "MySQL functions missing, have you compiled PHP with the --with-mysql option?\n" ); + } + + # Debugging hack -- fake cluster + if ( $wgAllDBsAreLocalhost ) { + $realServer = 'localhost'; + } else { + $realServer = $server; + } + $this->close(); + $this->mServer = $server; + $this->mUser = $user; + $this->mPassword = $password; + $this->mDBname = $dbName; + + $success = false; + + wfProfileIn("dbconnect-$server"); + + # Try to connect up to three times + # The kernel's default SYN retransmission period is far too slow for us, + # so we use a short timeout plus a manual retry. + $this->mConn = false; + $max = 3; + $this->installErrorHandler(); + for ( $i = 0; $i < $max && !$this->mConn; $i++ ) { + if ( $i > 1 ) { + usleep( 1000 ); + } + if ( $this->mFlags & DBO_PERSISTENT ) { + $this->mConn = mysql_pconnect( $realServer, $user, $password ); + } else { + # Create a new connection... + $this->mConn = mysql_connect( $realServer, $user, $password, true ); + } + if ($this->mConn === false) { + #$iplus = $i + 1; + #wfLogDBError("Connect loop error $iplus of $max ($server): " . mysql_errno() . " - " . mysql_error()."\n"); + } + } + $phpError = $this->restoreErrorHandler(); + + wfProfileOut("dbconnect-$server"); + + if ( $dbName != '' ) { + if ( $this->mConn !== false ) { + $success = @/**/mysql_select_db( $dbName, $this->mConn ); + if ( !$success ) { + $error = "Error selecting database $dbName on server {$this->mServer} " . + "from client host {$wguname['nodename']}\n"; + wfLogDBError(" Error selecting database $dbName on server {$this->mServer} \n"); + wfDebug( $error ); + } + } else { + wfDebug( "DB connection error\n" ); + wfDebug( "Server: $server, User: $user, Password: " . + substr( $password, 0, 3 ) . "..., error: " . mysql_error() . "\n" ); + $success = false; + } + } else { + # Delay USE query + $success = (bool)$this->mConn; + } + + if ( $success ) { + $version = $this->getServerVersion(); + if ( version_compare( $version, '4.1' ) >= 0 ) { + // Tell the server we're communicating with it in UTF-8. + // This may engage various charset conversions. + global $wgDBmysql5; + if( $wgDBmysql5 ) { + $this->query( 'SET NAMES utf8', __METHOD__ ); + } + // Turn off strict mode + $this->query( "SET sql_mode = ''", __METHOD__ ); + } + + // Turn off strict mode if it is on + } else { + $this->reportConnectionError( $phpError ); + } + + $this->mOpened = $success; + wfProfileOut( __METHOD__ ); + return $success; + } + /**@}}*/ + + protected function installErrorHandler() { + $this->mPHPError = false; + set_error_handler( array( $this, 'connectionErrorHandler' ) ); + } + + protected function restoreErrorHandler() { + restore_error_handler(); + return $this->mPHPError; + } + + protected function connectionErrorHandler( $errno, $errstr ) { + $this->mPHPError = $errstr; + } + + /** + * Closes a database connection. + * if it is open : commits any open transactions + * + * @return bool operation success. true if already closed. + */ + function close() + { + $this->mOpened = false; + if ( $this->mConn ) { + if ( $this->trxLevel() ) { + $this->immediateCommit(); + } + return mysql_close( $this->mConn ); + } else { + return true; + } + } + + /** + * @param string $error fallback error message, used if none is given by MySQL + */ + function reportConnectionError( $error = 'Unknown error' ) { + $myError = $this->lastError(); + if ( $myError ) { + $error = $myError; + } + + if ( $this->mFailFunction ) { + # Legacy error handling method + if ( !is_int( $this->mFailFunction ) ) { + $ff = $this->mFailFunction; + $ff( $this, $error ); + } + } else { + # New method + wfLogDBError( "Connection error: $error\n" ); + throw new DBConnectionError( $this, $error ); + } + } + + /** + * Usually aborts on failure. If errors are explicitly ignored, returns success. + * + * @param $sql String: SQL query + * @param $fname String: Name of the calling function, for profiling/SHOW PROCESSLIST + * comment (you can use __METHOD__ or add some extra info) + * @param $tempIgnore Bool: Whether to avoid throwing an exception on errors... + * maybe best to catch the exception instead? + * @return true for a successful write query, ResultWrapper object for a successful read query, + * or false on failure if $tempIgnore set + * @throws DBQueryError Thrown when the database returns an error of any kind + */ + public function query( $sql, $fname = '', $tempIgnore = false ) { + global $wgProfiler; + + $isMaster = !is_null( $this->getLBInfo( 'master' ) ); + if ( isset( $wgProfiler ) ) { + # generalizeSQL will probably cut down the query to reasonable + # logging size most of the time. The substr is really just a sanity check. + + # Who's been wasting my precious column space? -- TS + #$profName = 'query: ' . $fname . ' ' . substr( Database::generalizeSQL( $sql ), 0, 255 ); + + if ( $isMaster ) { + $queryProf = 'query-m: ' . substr( Database::generalizeSQL( $sql ), 0, 255 ); + $totalProf = 'Database::query-master'; + } else { + $queryProf = 'query: ' . substr( Database::generalizeSQL( $sql ), 0, 255 ); + $totalProf = 'Database::query'; + } + wfProfileIn( $totalProf ); + wfProfileIn( $queryProf ); + } + + $this->mLastQuery = $sql; + + # Add a comment for easy SHOW PROCESSLIST interpretation + #if ( $fname ) { + global $wgUser; + if ( is_object( $wgUser ) && !($wgUser instanceof StubObject) ) { + $userName = $wgUser->getName(); + if ( mb_strlen( $userName ) > 15 ) { + $userName = mb_substr( $userName, 0, 15 ) . '...'; + } + $userName = str_replace( '/', '', $userName ); + } else { + $userName = ''; + } + $commentedSql = preg_replace('/\s/', " /* $fname $userName */ ", $sql, 1); + #} else { + # $commentedSql = $sql; + #} + + # If DBO_TRX is set, start a transaction + if ( ( $this->mFlags & DBO_TRX ) && !$this->trxLevel() && + $sql != 'BEGIN' && $sql != 'COMMIT' && $sql != 'ROLLBACK') { + // avoid establishing transactions for SHOW and SET statements too - + // that would delay transaction initializations to once connection + // is really used by application + $sqlstart = substr($sql,0,10); // very much worth it, benchmark certified(tm) + if (strpos($sqlstart,"SHOW ")!==0 and strpos($sqlstart,"SET ")!==0) + $this->begin(); + } + + if ( $this->debug() ) { + $sqlx = substr( $commentedSql, 0, 500 ); + $sqlx = strtr( $sqlx, "\t\n", ' ' ); + if ( $isMaster ) { + wfDebug( "SQL-master: $sqlx\n" ); + } else { + wfDebug( "SQL: $sqlx\n" ); + } + } + + # Do the query and handle errors + $ret = $this->doQuery( $commentedSql ); + + # Try reconnecting if the connection was lost + if ( false === $ret && ( $this->lastErrno() == 2013 || $this->lastErrno() == 2006 ) ) { + # Transaction is gone, like it or not + $this->mTrxLevel = 0; + wfDebug( "Connection lost, reconnecting...\n" ); + if ( $this->ping() ) { + wfDebug( "Reconnected\n" ); + $sqlx = substr( $commentedSql, 0, 500 ); + $sqlx = strtr( $sqlx, "\t\n", ' ' ); + global $wgRequestTime; + $elapsed = round( microtime(true) - $wgRequestTime, 3 ); + wfLogDBError( "Connection lost and reconnected after {$elapsed}s, query: $sqlx\n" ); + $ret = $this->doQuery( $commentedSql ); + } else { + wfDebug( "Failed\n" ); + } + } + + if ( false === $ret ) { + $this->reportQueryError( $this->lastError(), $this->lastErrno(), $sql, $fname, $tempIgnore ); + } + + if ( isset( $wgProfiler ) ) { + wfProfileOut( $queryProf ); + wfProfileOut( $totalProf ); + } + return $this->resultObject( $ret ); + } + + /** + * The DBMS-dependent part of query() + * @param $sql String: SQL query. + * @return Result object to feed to fetchObject, fetchRow, ...; or false on failure + * @access private + */ + /*private*/ function doQuery( $sql ) { + if( $this->bufferResults() ) { + $ret = mysql_query( $sql, $this->mConn ); + } else { + $ret = mysql_unbuffered_query( $sql, $this->mConn ); + } + return $ret; + } + + /** + * @param $error + * @param $errno + * @param $sql + * @param string $fname + * @param bool $tempIgnore + */ + function reportQueryError( $error, $errno, $sql, $fname, $tempIgnore = false ) { + global $wgCommandLineMode; + # Ignore errors during error handling to avoid infinite recursion + $ignore = $this->ignoreErrors( true ); + ++$this->mErrorCount; + + if( $ignore || $tempIgnore ) { + wfDebug("SQL ERROR (ignored): $error\n"); + $this->ignoreErrors( $ignore ); + } else { + $sql1line = str_replace( "\n", "\\n", $sql ); + wfLogDBError("$fname\t{$this->mServer}\t$errno\t$error\t$sql1line\n"); + wfDebug("SQL ERROR: " . $error . "\n"); + throw new DBQueryError( $this, $error, $errno, $sql, $fname ); + } + } + + + /** + * Intended to be compatible with the PEAR::DB wrapper functions. + * http://pear.php.net/manual/en/package.database.db.intro-execute.php + * + * ? = scalar value, quoted as necessary + * ! = raw SQL bit (a function for instance) + * & = filename; reads the file and inserts as a blob + * (we don't use this though...) + */ + function prepare( $sql, $func = 'Database::prepare' ) { + /* MySQL doesn't support prepared statements (yet), so just + pack up the query for reference. We'll manually replace + the bits later. */ + return array( 'query' => $sql, 'func' => $func ); + } + + function freePrepared( $prepared ) { + /* No-op for MySQL */ + } + + /** + * Execute a prepared query with the various arguments + * @param string $prepared the prepared sql + * @param mixed $args Either an array here, or put scalars as varargs + */ + function execute( $prepared, $args = null ) { + if( !is_array( $args ) ) { + # Pull the var args + $args = func_get_args(); + array_shift( $args ); + } + $sql = $this->fillPrepared( $prepared['query'], $args ); + return $this->query( $sql, $prepared['func'] ); + } + + /** + * Prepare & execute an SQL statement, quoting and inserting arguments + * in the appropriate places. + * @param string $query + * @param string $args ... + */ + function safeQuery( $query, $args = null ) { + $prepared = $this->prepare( $query, 'Database::safeQuery' ); + if( !is_array( $args ) ) { + # Pull the var args + $args = func_get_args(); + array_shift( $args ); + } + $retval = $this->execute( $prepared, $args ); + $this->freePrepared( $prepared ); + return $retval; + } + + /** + * For faking prepared SQL statements on DBs that don't support + * it directly. + * @param string $preparedSql - a 'preparable' SQL statement + * @param array $args - array of arguments to fill it with + * @return string executable SQL + */ + function fillPrepared( $preparedQuery, $args ) { + reset( $args ); + $this->preparedArgs =& $args; + return preg_replace_callback( '/(\\\\[?!&]|[?!&])/', + array( &$this, 'fillPreparedArg' ), $preparedQuery ); + } + + /** + * preg_callback func for fillPrepared() + * The arguments should be in $this->preparedArgs and must not be touched + * while we're doing this. + * + * @param array $matches + * @return string + * @private + */ + function fillPreparedArg( $matches ) { + switch( $matches[1] ) { + case '\\?': return '?'; + case '\\!': return '!'; + case '\\&': return '&'; + } + list( /* $n */ , $arg ) = each( $this->preparedArgs ); + switch( $matches[1] ) { + case '?': return $this->addQuotes( $arg ); + case '!': return $arg; + case '&': + # return $this->addQuotes( file_get_contents( $arg ) ); + throw new DBUnexpectedError( $this, '& mode is not implemented. If it\'s really needed, uncomment the line above.' ); + default: + throw new DBUnexpectedError( $this, 'Received invalid match. This should never happen!' ); + } + } + + /**#@+ + * @param mixed $res A SQL result + */ + /** + * Free a result object + */ + function freeResult( $res ) { + if ( $res instanceof ResultWrapper ) { + $res = $res->result; + } + if ( !@/**/mysql_free_result( $res ) ) { + throw new DBUnexpectedError( $this, "Unable to free MySQL result" ); + } + } + + /** + * Fetch the next row from the given result object, in object form. + * Fields can be retrieved with $row->fieldname, with fields acting like + * member variables. + * + * @param $res SQL result object as returned from Database::query(), etc. + * @return MySQL row object + * @throws DBUnexpectedError Thrown if the database returns an error + */ + function fetchObject( $res ) { + if ( $res instanceof ResultWrapper ) { + $res = $res->result; + } + @/**/$row = mysql_fetch_object( $res ); + if( $this->lastErrno() ) { + throw new DBUnexpectedError( $this, 'Error in fetchObject(): ' . htmlspecialchars( $this->lastError() ) ); + } + return $row; + } + + /** + * Fetch the next row from the given result object, in associative array + * form. Fields are retrieved with $row['fieldname']. + * + * @param $res SQL result object as returned from Database::query(), etc. + * @return MySQL row object + * @throws DBUnexpectedError Thrown if the database returns an error + */ + function fetchRow( $res ) { + if ( $res instanceof ResultWrapper ) { + $res = $res->result; + } + @/**/$row = mysql_fetch_array( $res ); + if ( $this->lastErrno() ) { + throw new DBUnexpectedError( $this, 'Error in fetchRow(): ' . htmlspecialchars( $this->lastError() ) ); + } + return $row; + } + + /** + * Get the number of rows in a result object + */ + function numRows( $res ) { + if ( $res instanceof ResultWrapper ) { + $res = $res->result; + } + @/**/$n = mysql_num_rows( $res ); + if( $this->lastErrno() ) { + throw new DBUnexpectedError( $this, 'Error in numRows(): ' . htmlspecialchars( $this->lastError() ) ); + } + return $n; + } + + /** + * Get the number of fields in a result object + * See documentation for mysql_num_fields() + */ + function numFields( $res ) { + if ( $res instanceof ResultWrapper ) { + $res = $res->result; + } + return mysql_num_fields( $res ); + } + + /** + * Get a field name in a result object + * See documentation for mysql_field_name(): + * http://www.php.net/mysql_field_name + */ + function fieldName( $res, $n ) { + if ( $res instanceof ResultWrapper ) { + $res = $res->result; + } + return mysql_field_name( $res, $n ); + } + + /** + * Get the inserted value of an auto-increment row + * + * The value inserted should be fetched from nextSequenceValue() + * + * Example: + * $id = $dbw->nextSequenceValue('page_page_id_seq'); + * $dbw->insert('page',array('page_id' => $id)); + * $id = $dbw->insertId(); + */ + function insertId() { return mysql_insert_id( $this->mConn ); } + + /** + * Change the position of the cursor in a result object + * See mysql_data_seek() + */ + function dataSeek( $res, $row ) { + if ( $res instanceof ResultWrapper ) { + $res = $res->result; + } + return mysql_data_seek( $res, $row ); + } + + /** + * Get the last error number + * See mysql_errno() + */ + function lastErrno() { + if ( $this->mConn ) { + return mysql_errno( $this->mConn ); + } else { + return mysql_errno(); + } + } + + /** + * Get a description of the last error + * See mysql_error() for more details + */ + function lastError() { + if ( $this->mConn ) { + # Even if it's non-zero, it can still be invalid + wfSuppressWarnings(); + $error = mysql_error( $this->mConn ); + if ( !$error ) { + $error = mysql_error(); + } + wfRestoreWarnings(); + } else { + $error = mysql_error(); + } + if( $error ) { + $error .= ' (' . $this->mServer . ')'; + } + return $error; + } + /** + * Get the number of rows affected by the last write query + * See mysql_affected_rows() for more details + */ + function affectedRows() { return mysql_affected_rows( $this->mConn ); } + /**#@-*/ // end of template : @param $result + + /** + * Simple UPDATE wrapper + * Usually aborts on failure + * If errors are explicitly ignored, returns success + * + * This function exists for historical reasons, Database::update() has a more standard + * calling convention and feature set + */ + function set( $table, $var, $value, $cond, $fname = 'Database::set' ) + { + $table = $this->tableName( $table ); + $sql = "UPDATE $table SET $var = '" . + $this->strencode( $value ) . "' WHERE ($cond)"; + return (bool)$this->query( $sql, $fname ); + } + + /** + * Simple SELECT wrapper, returns a single field, input must be encoded + * Usually aborts on failure + * If errors are explicitly ignored, returns FALSE on failure + */ + function selectField( $table, $var, $cond='', $fname = 'Database::selectField', $options = array() ) { + if ( !is_array( $options ) ) { + $options = array( $options ); + } + $options['LIMIT'] = 1; + + $res = $this->select( $table, $var, $cond, $fname, $options ); + if ( $res === false || !$this->numRows( $res ) ) { + return false; + } + $row = $this->fetchRow( $res ); + if ( $row !== false ) { + $this->freeResult( $res ); + return $row[0]; + } else { + return false; + } + } + + /** + * Returns an optional USE INDEX clause to go after the table, and a + * string to go at the end of the query + * + * @private + * + * @param array $options an associative array of options to be turned into + * an SQL query, valid keys are listed in the function. + * @return array + */ + function makeSelectOptions( $options ) { + $preLimitTail = $postLimitTail = ''; + $startOpts = ''; + + $noKeyOptions = array(); + foreach ( $options as $key => $option ) { + if ( is_numeric( $key ) ) { + $noKeyOptions[$option] = true; + } + } + + if ( isset( $options['GROUP BY'] ) ) $preLimitTail .= " GROUP BY {$options['GROUP BY']}"; + if ( isset( $options['HAVING'] ) ) $preLimitTail .= " HAVING {$options['HAVING']}"; + if ( isset( $options['ORDER BY'] ) ) $preLimitTail .= " ORDER BY {$options['ORDER BY']}"; + + //if (isset($options['LIMIT'])) { + // $tailOpts .= $this->limitResult('', $options['LIMIT'], + // isset($options['OFFSET']) ? $options['OFFSET'] + // : false); + //} + + if ( isset( $noKeyOptions['FOR UPDATE'] ) ) $postLimitTail .= ' FOR UPDATE'; + if ( isset( $noKeyOptions['LOCK IN SHARE MODE'] ) ) $postLimitTail .= ' LOCK IN SHARE MODE'; + if ( isset( $noKeyOptions['DISTINCT'] ) || isset( $noKeyOptions['DISTINCTROW'] ) ) $startOpts .= 'DISTINCT'; + + # Various MySQL extensions + if ( isset( $noKeyOptions['STRAIGHT_JOIN'] ) ) $startOpts .= ' /*! STRAIGHT_JOIN */'; + if ( isset( $noKeyOptions['HIGH_PRIORITY'] ) ) $startOpts .= ' HIGH_PRIORITY'; + if ( isset( $noKeyOptions['SQL_BIG_RESULT'] ) ) $startOpts .= ' SQL_BIG_RESULT'; + if ( isset( $noKeyOptions['SQL_BUFFER_RESULT'] ) ) $startOpts .= ' SQL_BUFFER_RESULT'; + if ( isset( $noKeyOptions['SQL_SMALL_RESULT'] ) ) $startOpts .= ' SQL_SMALL_RESULT'; + if ( isset( $noKeyOptions['SQL_CALC_FOUND_ROWS'] ) ) $startOpts .= ' SQL_CALC_FOUND_ROWS'; + if ( isset( $noKeyOptions['SQL_CACHE'] ) ) $startOpts .= ' SQL_CACHE'; + if ( isset( $noKeyOptions['SQL_NO_CACHE'] ) ) $startOpts .= ' SQL_NO_CACHE'; + + if ( isset( $options['USE INDEX'] ) && ! is_array( $options['USE INDEX'] ) ) { + $useIndex = $this->useIndexClause( $options['USE INDEX'] ); + } else { + $useIndex = ''; + } + + return array( $startOpts, $useIndex, $preLimitTail, $postLimitTail ); + } + + /** + * SELECT wrapper + * + * @param mixed $table Array or string, table name(s) (prefix auto-added) + * @param mixed $vars Array or string, field name(s) to be retrieved + * @param mixed $conds Array or string, condition(s) for WHERE + * @param string $fname Calling function name (use __METHOD__) for logs/profiling + * @param array $options Associative array of options (e.g. array('GROUP BY' => 'page_title')), + * see Database::makeSelectOptions code for list of supported stuff + * @param array $join_conds Associative array of table join conditions (optional) + * (e.g. array( 'page' => array('LEFT JOIN','page_latest=rev_id') ) + * @return mixed Database result resource (feed to Database::fetchObject or whatever), or false on failure + */ + function select( $table, $vars, $conds='', $fname = 'Database::select', $options = array(), $join_conds = array() ) + { + $sql = $this->selectSQLText( $table, $vars, $conds, $fname, $options, $join_conds ); + return $this->query( $sql, $fname ); + } + + /** + * SELECT wrapper + * + * @param mixed $table Array or string, table name(s) (prefix auto-added) + * @param mixed $vars Array or string, field name(s) to be retrieved + * @param mixed $conds Array or string, condition(s) for WHERE + * @param string $fname Calling function name (use __METHOD__) for logs/profiling + * @param array $options Associative array of options (e.g. array('GROUP BY' => 'page_title')), + * see Database::makeSelectOptions code for list of supported stuff + * @param array $join_conds Associative array of table join conditions (optional) + * (e.g. array( 'page' => array('LEFT JOIN','page_latest=rev_id') ) + * @return string, the SQL text + */ + function selectSQLText( $table, $vars, $conds='', $fname = 'Database::select', $options = array(), $join_conds = array() ) { + if( is_array( $vars ) ) { + $vars = implode( ',', $vars ); + } + if( !is_array( $options ) ) { + $options = array( $options ); + } + if( is_array( $table ) ) { + if ( !empty($join_conds) || ( isset( $options['USE INDEX'] ) && is_array( @$options['USE INDEX'] ) ) ) + $from = ' FROM ' . $this->tableNamesWithUseIndexOrJOIN( $table, @$options['USE INDEX'], $join_conds ); + else + $from = ' FROM ' . implode( ',', array_map( array( &$this, 'tableName' ), $table ) ); + } elseif ($table!='') { + if ($table{0}==' ') { + $from = ' FROM ' . $table; + } else { + $from = ' FROM ' . $this->tableName( $table ); + } + } else { + $from = ''; + } + + list( $startOpts, $useIndex, $preLimitTail, $postLimitTail ) = $this->makeSelectOptions( $options ); + + if( !empty( $conds ) ) { + if ( is_array( $conds ) ) { + $conds = $this->makeList( $conds, LIST_AND ); + } + $sql = "SELECT $startOpts $vars $from $useIndex WHERE $conds $preLimitTail"; + } else { + $sql = "SELECT $startOpts $vars $from $useIndex $preLimitTail"; + } + + if (isset($options['LIMIT'])) + $sql = $this->limitResult($sql, $options['LIMIT'], + isset($options['OFFSET']) ? $options['OFFSET'] : false); + $sql = "$sql $postLimitTail"; + + if (isset($options['EXPLAIN'])) { + $sql = 'EXPLAIN ' . $sql; + } + return $sql; + } + + /** + * Single row SELECT wrapper + * Aborts or returns FALSE on error + * + * $vars: the selected variables + * $conds: a condition map, terms are ANDed together. + * Items with numeric keys are taken to be literal conditions + * Takes an array of selected variables, and a condition map, which is ANDed + * e.g: selectRow( "page", array( "page_id" ), array( "page_namespace" => + * NS_MAIN, "page_title" => "Astronomy" ) ) would return an object where + * $obj- >page_id is the ID of the Astronomy article + * + * @todo migrate documentation to phpdocumentor format + */ + function selectRow( $table, $vars, $conds, $fname = 'Database::selectRow', $options = array(), $join_conds = array() ) { + $options['LIMIT'] = 1; + $res = $this->select( $table, $vars, $conds, $fname, $options, $join_conds ); + if ( $res === false ) + return false; + if ( !$this->numRows($res) ) { + $this->freeResult($res); + return false; + } + $obj = $this->fetchObject( $res ); + $this->freeResult( $res ); + return $obj; + + } + + /** + * Estimate rows in dataset + * Returns estimated count, based on EXPLAIN output + * Takes same arguments as Database::select() + */ + + function estimateRowCount( $table, $vars='*', $conds='', $fname = 'Database::estimateRowCount', $options = array() ) { + $options['EXPLAIN']=true; + $res = $this->select ($table, $vars, $conds, $fname, $options ); + if ( $res === false ) + return false; + if (!$this->numRows($res)) { + $this->freeResult($res); + return 0; + } + + $rows=1; + + while( $plan = $this->fetchObject( $res ) ) { + $rows *= ($plan->rows > 0)?$plan->rows:1; // avoid resetting to zero + } + + $this->freeResult($res); + return $rows; + } + + + /** + * Removes most variables from an SQL query and replaces them with X or N for numbers. + * It's only slightly flawed. Don't use for anything important. + * + * @param string $sql A SQL Query + * @static + */ + static function generalizeSQL( $sql ) { + # This does the same as the regexp below would do, but in such a way + # as to avoid crashing php on some large strings. + # $sql = preg_replace ( "/'([^\\\\']|\\\\.)*'|\"([^\\\\\"]|\\\\.)*\"/", "'X'", $sql); + + $sql = str_replace ( "\\\\", '', $sql); + $sql = str_replace ( "\\'", '', $sql); + $sql = str_replace ( "\\\"", '', $sql); + $sql = preg_replace ("/'.*'/s", "'X'", $sql); + $sql = preg_replace ('/".*"/s', "'X'", $sql); + + # All newlines, tabs, etc replaced by single space + $sql = preg_replace ( '/\s+/', ' ', $sql); + + # All numbers => N + $sql = preg_replace ('/-?[0-9]+/s', 'N', $sql); + + return $sql; + } + + /** + * Determines whether a field exists in a table + * Usually aborts on failure + * If errors are explicitly ignored, returns NULL on failure + */ + function fieldExists( $table, $field, $fname = 'Database::fieldExists' ) { + $table = $this->tableName( $table ); + $res = $this->query( 'DESCRIBE '.$table, $fname ); + if ( !$res ) { + return NULL; + } + + $found = false; + + while ( $row = $this->fetchObject( $res ) ) { + if ( $row->Field == $field ) { + $found = true; + break; + } + } + return $found; + } + + /** + * Determines whether an index exists + * Usually aborts on failure + * If errors are explicitly ignored, returns NULL on failure + */ + function indexExists( $table, $index, $fname = 'Database::indexExists' ) { + $info = $this->indexInfo( $table, $index, $fname ); + if ( is_null( $info ) ) { + return NULL; + } else { + return $info !== false; + } + } + + + /** + * Get information about an index into an object + * Returns false if the index does not exist + */ + function indexInfo( $table, $index, $fname = 'Database::indexInfo' ) { + # SHOW INDEX works in MySQL 3.23.58, but SHOW INDEXES does not. + # SHOW INDEX should work for 3.x and up: + # http://dev.mysql.com/doc/mysql/en/SHOW_INDEX.html + $table = $this->tableName( $table ); + $sql = 'SHOW INDEX FROM '.$table; + $res = $this->query( $sql, $fname ); + if ( !$res ) { + return NULL; + } + + $result = array(); + while ( $row = $this->fetchObject( $res ) ) { + if ( $row->Key_name == $index ) { + $result[] = $row; + } + } + $this->freeResult($res); + + return empty($result) ? false : $result; + } + + /** + * Query whether a given table exists + */ + function tableExists( $table ) { + $table = $this->tableName( $table ); + $old = $this->ignoreErrors( true ); + $res = $this->query( "SELECT 1 FROM $table LIMIT 1" ); + $this->ignoreErrors( $old ); + if( $res ) { + $this->freeResult( $res ); + return true; + } else { + return false; + } + } + + /** + * mysql_fetch_field() wrapper + * Returns false if the field doesn't exist + * + * @param $table + * @param $field + */ + function fieldInfo( $table, $field ) { + $table = $this->tableName( $table ); + $res = $this->query( "SELECT * FROM $table LIMIT 1" ); + $n = mysql_num_fields( $res->result ); + for( $i = 0; $i < $n; $i++ ) { + $meta = mysql_fetch_field( $res->result, $i ); + if( $field == $meta->name ) { + return new MySQLField($meta); + } + } + return false; + } + + /** + * mysql_field_type() wrapper + */ + function fieldType( $res, $index ) { + if ( $res instanceof ResultWrapper ) { + $res = $res->result; + } + return mysql_field_type( $res, $index ); + } + + /** + * Determines if a given index is unique + */ + function indexUnique( $table, $index ) { + $indexInfo = $this->indexInfo( $table, $index ); + if ( !$indexInfo ) { + return NULL; + } + return !$indexInfo[0]->Non_unique; + } + + /** + * INSERT wrapper, inserts an array into a table + * + * $a may be a single associative array, or an array of these with numeric keys, for + * multi-row insert. + * + * Usually aborts on failure + * If errors are explicitly ignored, returns success + */ + function insert( $table, $a, $fname = 'Database::insert', $options = array() ) { + # No rows to insert, easy just return now + if ( !count( $a ) ) { + return true; + } + + $table = $this->tableName( $table ); + if ( !is_array( $options ) ) { + $options = array( $options ); + } + if ( isset( $a[0] ) && is_array( $a[0] ) ) { + $multi = true; + $keys = array_keys( $a[0] ); + } else { + $multi = false; + $keys = array_keys( $a ); + } + + $sql = 'INSERT ' . implode( ' ', $options ) . + " INTO $table (" . implode( ',', $keys ) . ') VALUES '; + + if ( $multi ) { + $first = true; + foreach ( $a as $row ) { + if ( $first ) { + $first = false; + } else { + $sql .= ','; + } + $sql .= '(' . $this->makeList( $row ) . ')'; + } + } else { + $sql .= '(' . $this->makeList( $a ) . ')'; + } + return (bool)$this->query( $sql, $fname ); + } + + /** + * Make UPDATE options for the Database::update function + * + * @private + * @param array $options The options passed to Database::update + * @return string + */ + function makeUpdateOptions( $options ) { + if( !is_array( $options ) ) { + $options = array( $options ); + } + $opts = array(); + if ( in_array( 'LOW_PRIORITY', $options ) ) + $opts[] = $this->lowPriorityOption(); + if ( in_array( 'IGNORE', $options ) ) + $opts[] = 'IGNORE'; + return implode(' ', $opts); + } + + /** + * UPDATE wrapper, takes a condition array and a SET array + * + * @param string $table The table to UPDATE + * @param array $values An array of values to SET + * @param array $conds An array of conditions (WHERE). Use '*' to update all rows. + * @param string $fname The Class::Function calling this function + * (for the log) + * @param array $options An array of UPDATE options, can be one or + * more of IGNORE, LOW_PRIORITY + * @return bool + */ + function update( $table, $values, $conds, $fname = 'Database::update', $options = array() ) { + $table = $this->tableName( $table ); + $opts = $this->makeUpdateOptions( $options ); + $sql = "UPDATE $opts $table SET " . $this->makeList( $values, LIST_SET ); + if ( $conds != '*' ) { + $sql .= " WHERE " . $this->makeList( $conds, LIST_AND ); + } + return $this->query( $sql, $fname ); + } + + /** + * Makes an encoded list of strings from an array + * $mode: + * LIST_COMMA - comma separated, no field names + * LIST_AND - ANDed WHERE clause (without the WHERE) + * LIST_OR - ORed WHERE clause (without the WHERE) + * LIST_SET - comma separated with field names, like a SET clause + * LIST_NAMES - comma separated field names + */ + function makeList( $a, $mode = LIST_COMMA ) { + if ( !is_array( $a ) ) { + throw new DBUnexpectedError( $this, 'Database::makeList called with incorrect parameters' ); + } + + $first = true; + $list = ''; + foreach ( $a as $field => $value ) { + if ( !$first ) { + if ( $mode == LIST_AND ) { + $list .= ' AND '; + } elseif($mode == LIST_OR) { + $list .= ' OR '; + } else { + $list .= ','; + } + } else { + $first = false; + } + if ( ($mode == LIST_AND || $mode == LIST_OR) && is_numeric( $field ) ) { + $list .= "($value)"; + } elseif ( ($mode == LIST_SET) && is_numeric( $field ) ) { + $list .= "$value"; + } elseif ( ($mode == LIST_AND || $mode == LIST_OR) && is_array($value) ) { + if( count( $value ) == 0 ) { + throw new MWException( __METHOD__.': empty input' ); + } elseif( count( $value ) == 1 ) { + // Special-case single values, as IN isn't terribly efficient + // Don't necessarily assume the single key is 0; we don't + // enforce linear numeric ordering on other arrays here. + $value = array_values( $value ); + $list .= $field." = ".$this->addQuotes( $value[0] ); + } else { + $list .= $field." IN (".$this->makeList($value).") "; + } + } elseif( is_null($value) ) { + if ( $mode == LIST_AND || $mode == LIST_OR ) { + $list .= "$field IS "; + } elseif ( $mode == LIST_SET ) { + $list .= "$field = "; + } + $list .= 'NULL'; + } else { + if ( $mode == LIST_AND || $mode == LIST_OR || $mode == LIST_SET ) { + $list .= "$field = "; + } + $list .= $mode == LIST_NAMES ? $value : $this->addQuotes( $value ); + } + } + return $list; + } + + /** + * Change the current database + */ + function selectDB( $db ) { + $this->mDBname = $db; + return mysql_select_db( $db, $this->mConn ); + } + + /** + * Get the current DB name + */ + function getDBname() { + return $this->mDBname; + } + + /** + * Get the server hostname or IP address + */ + function getServer() { + return $this->mServer; + } + + /** + * Format a table name ready for use in constructing an SQL query + * + * This does two important things: it quotes the table names to clean them up, + * and it adds a table prefix if only given a table name with no quotes. + * + * All functions of this object which require a table name call this function + * themselves. Pass the canonical name to such functions. This is only needed + * when calling query() directly. + * + * @param string $name database table name + * @return string full database name + */ + function tableName( $name ) { + global $wgSharedDB, $wgSharedPrefix, $wgSharedTables; + # Skip the entire process when we have a string quoted on both ends. + # Note that we check the end so that we will still quote any use of + # use of `database`.table. But won't break things if someone wants + # to query a database table with a dot in the name. + if ( $name[0] == '`' && substr( $name, -1, 1 ) == '`' ) return $name; + + # Lets test for any bits of text that should never show up in a table + # name. Basically anything like JOIN or ON which are actually part of + # SQL queries, but may end up inside of the table value to combine + # sql. Such as how the API is doing. + # Note that we use a whitespace test rather than a \b test to avoid + # any remote case where a word like on may be inside of a table name + # surrounded by symbols which may be considered word breaks. + if( preg_match( '/(^|\s)(DISTINCT|JOIN|ON|AS)(\s|$)/i', $name ) !== 0 ) return $name; + + # Split database and table into proper variables. + # We reverse the explode so that database.table and table both output + # the correct table. + $dbDetails = array_reverse( explode( '.', $name, 2 ) ); + if( isset( $dbDetails[1] ) ) @list( $table, $database ) = $dbDetails; + else @list( $table ) = $dbDetails; + $prefix = $this->mTablePrefix; # Default prefix + + # A database name has been specified in input. Quote the table name + # because we don't want any prefixes added. + if( isset($database) ) $table = ( $table[0] == '`' ? $table : "`{$table}`" ); + + # Note that we use the long format because php will complain in in_array if + # the input is not an array, and will complain in is_array if it is not set. + if( !isset( $database ) # Don't use shared database if pre selected. + && isset( $wgSharedDB ) # We have a shared database + && $table[0] != '`' # Paranoia check to prevent shared tables listing '`table`' + && isset( $wgSharedTables ) + && is_array( $wgSharedTables ) + && in_array( $table, $wgSharedTables ) ) { # A shared table is selected + $database = $wgSharedDB; + $prefix = isset( $wgSharedPrefix ) ? $wgSharedPrefix : $prefix; + } + + # Quote the $database and $table and apply the prefix if not quoted. + if( isset($database) ) $database = ( $database[0] == '`' ? $database : "`{$database}`" ); + $table = ( $table[0] == '`' ? $table : "`{$prefix}{$table}`" ); + + # Merge our database and table into our final table name. + $tableName = ( isset($database) ? "{$database}.{$table}" : "{$table}" ); + + # We're finished, return. + return $tableName; + } + + /** + * Fetch a number of table names into an array + * This is handy when you need to construct SQL for joins + * + * Example: + * extract($dbr->tableNames('user','watchlist')); + * $sql = "SELECT wl_namespace,wl_title FROM $watchlist,$user + * WHERE wl_user=user_id AND wl_user=$nameWithQuotes"; + */ + public function tableNames() { + $inArray = func_get_args(); + $retVal = array(); + foreach ( $inArray as $name ) { + $retVal[$name] = $this->tableName( $name ); + } + return $retVal; + } + + /** + * Fetch a number of table names into an zero-indexed numerical array + * This is handy when you need to construct SQL for joins + * + * Example: + * list( $user, $watchlist ) = $dbr->tableNamesN('user','watchlist'); + * $sql = "SELECT wl_namespace,wl_title FROM $watchlist,$user + * WHERE wl_user=user_id AND wl_user=$nameWithQuotes"; + */ + public function tableNamesN() { + $inArray = func_get_args(); + $retVal = array(); + foreach ( $inArray as $name ) { + $retVal[] = $this->tableName( $name ); + } + return $retVal; + } + + /** + * @private + */ + function tableNamesWithUseIndexOrJOIN( $tables, $use_index = array(), $join_conds = array() ) { + $ret = array(); + $retJOIN = array(); + $use_index_safe = is_array($use_index) ? $use_index : array(); + $join_conds_safe = is_array($join_conds) ? $join_conds : array(); + foreach ( $tables as $table ) { + // Is there a JOIN and INDEX clause for this table? + if ( isset($join_conds_safe[$table]) && isset($use_index_safe[$table]) ) { + $tableClause = $join_conds_safe[$table][0] . ' ' . $this->tableName( $table ); + $tableClause .= ' ' . $this->useIndexClause( implode( ',', (array)$use_index_safe[$table] ) ); + $tableClause .= ' ON (' . $this->makeList((array)$join_conds_safe[$table][1], LIST_AND) . ')'; + $retJOIN[] = $tableClause; + // Is there an INDEX clause? + } else if ( isset($use_index_safe[$table]) ) { + $tableClause = $this->tableName( $table ); + $tableClause .= ' ' . $this->useIndexClause( implode( ',', (array)$use_index_safe[$table] ) ); + $ret[] = $tableClause; + // Is there a JOIN clause? + } else if ( isset($join_conds_safe[$table]) ) { + $tableClause = $join_conds_safe[$table][0] . ' ' . $this->tableName( $table ); + $tableClause .= ' ON (' . $this->makeList((array)$join_conds_safe[$table][1], LIST_AND) . ')'; + $retJOIN[] = $tableClause; + } else { + $tableClause = $this->tableName( $table ); + $ret[] = $tableClause; + } + } + // We can't separate explicit JOIN clauses with ',', use ' ' for those + $straightJoins = !empty($ret) ? implode( ',', $ret ) : ""; + $otherJoins = !empty($retJOIN) ? implode( ' ', $retJOIN ) : ""; + // Compile our final table clause + return implode(' ',array($straightJoins,$otherJoins) ); + } + + /** + * Wrapper for addslashes() + * @param string $s String to be slashed. + * @return string slashed string. + */ + function strencode( $s ) { + return mysql_real_escape_string( $s, $this->mConn ); + } + + /** + * If it's a string, adds quotes and backslashes + * Otherwise returns as-is + */ + function addQuotes( $s ) { + if ( is_null( $s ) ) { + return 'NULL'; + } else { + # This will also quote numeric values. This should be harmless, + # and protects against weird problems that occur when they really + # _are_ strings such as article titles and string->number->string + # conversion is not 1:1. + return "'" . $this->strencode( $s ) . "'"; + } + } + + /** + * Escape string for safe LIKE usage + */ + function escapeLike( $s ) { + $s=$this->strencode( $s ); + $s=str_replace(array('%','_'),array('\%','\_'),$s); + return $s; + } + + /** + * Returns an appropriately quoted sequence value for inserting a new row. + * MySQL has autoincrement fields, so this is just NULL. But the PostgreSQL + * subclass will return an integer, and save the value for insertId() + */ + function nextSequenceValue( $seqName ) { + return NULL; + } + + /** + * USE INDEX clause + * PostgreSQL doesn't have them and returns "" + */ + function useIndexClause( $index ) { + return "FORCE INDEX ($index)"; + } + + /** + * REPLACE query wrapper + * PostgreSQL simulates this with a DELETE followed by INSERT + * $row is the row to insert, an associative array + * $uniqueIndexes is an array of indexes. Each element may be either a + * field name or an array of field names + * + * It may be more efficient to leave off unique indexes which are unlikely to collide. + * However if you do this, you run the risk of encountering errors which wouldn't have + * occurred in MySQL + * + * @todo migrate comment to phodocumentor format + */ + function replace( $table, $uniqueIndexes, $rows, $fname = 'Database::replace' ) { + $table = $this->tableName( $table ); + + # Single row case + if ( !is_array( reset( $rows ) ) ) { + $rows = array( $rows ); + } + + $sql = "REPLACE INTO $table (" . implode( ',', array_keys( $rows[0] ) ) .') VALUES '; + $first = true; + foreach ( $rows as $row ) { + if ( $first ) { + $first = false; + } else { + $sql .= ','; + } + $sql .= '(' . $this->makeList( $row ) . ')'; + } + return $this->query( $sql, $fname ); + } + + /** + * DELETE where the condition is a join + * MySQL does this with a multi-table DELETE syntax, PostgreSQL does it with sub-selects + * + * For safety, an empty $conds will not delete everything. If you want to delete all rows where the + * join condition matches, set $conds='*' + * + * DO NOT put the join condition in $conds + * + * @param string $delTable The table to delete from. + * @param string $joinTable The other table. + * @param string $delVar The variable to join on, in the first table. + * @param string $joinVar The variable to join on, in the second table. + * @param array $conds Condition array of field names mapped to variables, ANDed together in the WHERE clause + */ + function deleteJoin( $delTable, $joinTable, $delVar, $joinVar, $conds, $fname = 'Database::deleteJoin' ) { + if ( !$conds ) { + throw new DBUnexpectedError( $this, 'Database::deleteJoin() called with empty $conds' ); + } + + $delTable = $this->tableName( $delTable ); + $joinTable = $this->tableName( $joinTable ); + $sql = "DELETE $delTable FROM $delTable, $joinTable WHERE $delVar=$joinVar "; + if ( $conds != '*' ) { + $sql .= ' AND ' . $this->makeList( $conds, LIST_AND ); + } + + return $this->query( $sql, $fname ); + } + + /** + * Returns the size of a text field, or -1 for "unlimited" + */ + function textFieldSize( $table, $field ) { + $table = $this->tableName( $table ); + $sql = "SHOW COLUMNS FROM $table LIKE \"$field\";"; + $res = $this->query( $sql, 'Database::textFieldSize' ); + $row = $this->fetchObject( $res ); + $this->freeResult( $res ); + + $m = array(); + if ( preg_match( '/\((.*)\)/', $row->Type, $m ) ) { + $size = $m[1]; + } else { + $size = -1; + } + return $size; + } + + /** + * @return string Returns the text of the low priority option if it is supported, or a blank string otherwise + */ + function lowPriorityOption() { + return 'LOW_PRIORITY'; + } + + /** + * DELETE query wrapper + * + * Use $conds == "*" to delete all rows + */ + function delete( $table, $conds, $fname = 'Database::delete' ) { + if ( !$conds ) { + throw new DBUnexpectedError( $this, 'Database::delete() called with no conditions' ); + } + $table = $this->tableName( $table ); + $sql = "DELETE FROM $table"; + if ( $conds != '*' ) { + $sql .= ' WHERE ' . $this->makeList( $conds, LIST_AND ); + } + return $this->query( $sql, $fname ); + } + + /** + * INSERT SELECT wrapper + * $varMap must be an associative array of the form array( 'dest1' => 'source1', ...) + * Source items may be literals rather than field names, but strings should be quoted with Database::addQuotes() + * $conds may be "*" to copy the whole table + * srcTable may be an array of tables. + */ + function insertSelect( $destTable, $srcTable, $varMap, $conds, $fname = 'Database::insertSelect', + $insertOptions = array(), $selectOptions = array() ) + { + $destTable = $this->tableName( $destTable ); + if ( is_array( $insertOptions ) ) { + $insertOptions = implode( ' ', $insertOptions ); + } + if( !is_array( $selectOptions ) ) { + $selectOptions = array( $selectOptions ); + } + list( $startOpts, $useIndex, $tailOpts ) = $this->makeSelectOptions( $selectOptions ); + if( is_array( $srcTable ) ) { + $srcTable = implode( ',', array_map( array( &$this, 'tableName' ), $srcTable ) ); + } else { + $srcTable = $this->tableName( $srcTable ); + } + $sql = "INSERT $insertOptions INTO $destTable (" . implode( ',', array_keys( $varMap ) ) . ')' . + " SELECT $startOpts " . implode( ',', $varMap ) . + " FROM $srcTable $useIndex "; + if ( $conds != '*' ) { + $sql .= ' WHERE ' . $this->makeList( $conds, LIST_AND ); + } + $sql .= " $tailOpts"; + return $this->query( $sql, $fname ); + } + + /** + * Construct a LIMIT query with optional offset + * This is used for query pages + * $sql string SQL query we will append the limit too + * $limit integer the SQL limit + * $offset integer the SQL offset (default false) + */ + function limitResult($sql, $limit, $offset=false) { + if( !is_numeric($limit) ) { + throw new DBUnexpectedError( $this, "Invalid non-numeric limit passed to limitResult()\n" ); + } + return "$sql LIMIT " + . ( (is_numeric($offset) && $offset != 0) ? "{$offset}," : "" ) + . "{$limit} "; + } + function limitResultForUpdate($sql, $num) { + return $this->limitResult($sql, $num, 0); + } + + /** + * Returns an SQL expression for a simple conditional. + * Uses IF on MySQL. + * + * @param string $cond SQL expression which will result in a boolean value + * @param string $trueVal SQL expression to return if true + * @param string $falseVal SQL expression to return if false + * @return string SQL fragment + */ + function conditional( $cond, $trueVal, $falseVal ) { + return " IF($cond, $trueVal, $falseVal) "; + } + + /** + * Returns a comand for str_replace function in SQL query. + * Uses REPLACE() in MySQL + * + * @param string $orig String or column to modify + * @param string $old String or column to seek + * @param string $new String or column to replace with + */ + function strreplace( $orig, $old, $new ) { + return "REPLACE({$orig}, {$old}, {$new})"; + } + + /** + * Determines if the last failure was due to a deadlock + */ + function wasDeadlock() { + return $this->lastErrno() == 1213; + } + + /** + * Perform a deadlock-prone transaction. + * + * This function invokes a callback function to perform a set of write + * queries. If a deadlock occurs during the processing, the transaction + * will be rolled back and the callback function will be called again. + * + * Usage: + * $dbw->deadlockLoop( callback, ... ); + * + * Extra arguments are passed through to the specified callback function. + * + * Returns whatever the callback function returned on its successful, + * iteration, or false on error, for example if the retry limit was + * reached. + */ + function deadlockLoop() { + $myFname = 'Database::deadlockLoop'; + + $this->begin(); + $args = func_get_args(); + $function = array_shift( $args ); + $oldIgnore = $this->ignoreErrors( true ); + $tries = DEADLOCK_TRIES; + if ( is_array( $function ) ) { + $fname = $function[0]; + } else { + $fname = $function; + } + do { + $retVal = call_user_func_array( $function, $args ); + $error = $this->lastError(); + $errno = $this->lastErrno(); + $sql = $this->lastQuery(); + + if ( $errno ) { + if ( $this->wasDeadlock() ) { + # Retry + usleep( mt_rand( DEADLOCK_DELAY_MIN, DEADLOCK_DELAY_MAX ) ); + } else { + $this->reportQueryError( $error, $errno, $sql, $fname ); + } + } + } while( $this->wasDeadlock() && --$tries > 0 ); + $this->ignoreErrors( $oldIgnore ); + if ( $tries <= 0 ) { + $this->query( 'ROLLBACK', $myFname ); + $this->reportQueryError( $error, $errno, $sql, $fname ); + return false; + } else { + $this->query( 'COMMIT', $myFname ); + return $retVal; + } + } + + /** + * Do a SELECT MASTER_POS_WAIT() + * + * @param string $file the binlog file + * @param string $pos the binlog position + * @param integer $timeout the maximum number of seconds to wait for synchronisation + */ + function masterPosWait( MySQLMasterPos $pos, $timeout ) { + $fname = 'Database::masterPosWait'; + wfProfileIn( $fname ); + + # Commit any open transactions + if ( $this->mTrxLevel ) { + $this->immediateCommit(); + } + + if ( !is_null( $this->mFakeSlaveLag ) ) { + $wait = intval( ( $pos->pos - microtime(true) + $this->mFakeSlaveLag ) * 1e6 ); + if ( $wait > $timeout * 1e6 ) { + wfDebug( "Fake slave timed out waiting for $pos ($wait us)\n" ); + wfProfileOut( $fname ); + return -1; + } elseif ( $wait > 0 ) { + wfDebug( "Fake slave waiting $wait us\n" ); + usleep( $wait ); + wfProfileOut( $fname ); + return 1; + } else { + wfDebug( "Fake slave up to date ($wait us)\n" ); + wfProfileOut( $fname ); + return 0; + } + } + + # Call doQuery() directly, to avoid opening a transaction if DBO_TRX is set + $encFile = $this->addQuotes( $pos->file ); + $encPos = intval( $pos->pos ); + $sql = "SELECT MASTER_POS_WAIT($encFile, $encPos, $timeout)"; + $res = $this->doQuery( $sql ); + if ( $res && $row = $this->fetchRow( $res ) ) { + $this->freeResult( $res ); + wfProfileOut( $fname ); + return $row[0]; + } else { + wfProfileOut( $fname ); + return false; + } + } + + /** + * Get the position of the master from SHOW SLAVE STATUS + */ + function getSlavePos() { + if ( !is_null( $this->mFakeSlaveLag ) ) { + $pos = new MySQLMasterPos( 'fake', microtime(true) - $this->mFakeSlaveLag ); + wfDebug( __METHOD__.": fake slave pos = $pos\n" ); + return $pos; + } + $res = $this->query( 'SHOW SLAVE STATUS', 'Database::getSlavePos' ); + $row = $this->fetchObject( $res ); + if ( $row ) { + return new MySQLMasterPos( $row->Master_Log_File, $row->Read_Master_Log_Pos ); + } else { + return false; + } + } + + /** + * Get the position of the master from SHOW MASTER STATUS + */ + function getMasterPos() { + if ( $this->mFakeMaster ) { + return new MySQLMasterPos( 'fake', microtime( true ) ); + } + $res = $this->query( 'SHOW MASTER STATUS', 'Database::getMasterPos' ); + $row = $this->fetchObject( $res ); + if ( $row ) { + return new MySQLMasterPos( $row->File, $row->Position ); + } else { + return false; + } + } + + /** + * Begin a transaction, committing any previously open transaction + */ + function begin( $fname = 'Database::begin' ) { + $this->query( 'BEGIN', $fname ); + $this->mTrxLevel = 1; + } + + /** + * End a transaction + */ + function commit( $fname = 'Database::commit' ) { + $this->query( 'COMMIT', $fname ); + $this->mTrxLevel = 0; + } + + /** + * Rollback a transaction. + * No-op on non-transactional databases. + */ + function rollback( $fname = 'Database::rollback' ) { + $this->query( 'ROLLBACK', $fname, true ); + $this->mTrxLevel = 0; + } + + /** + * Begin a transaction, committing any previously open transaction + * @deprecated use begin() + */ + function immediateBegin( $fname = 'Database::immediateBegin' ) { + $this->begin(); + } + + /** + * Commit transaction, if one is open + * @deprecated use commit() + */ + function immediateCommit( $fname = 'Database::immediateCommit' ) { + $this->commit(); + } + + /** + * Return MW-style timestamp used for MySQL schema + */ + function timestamp( $ts=0 ) { + return wfTimestamp(TS_MW,$ts); + } + + /** + * Local database timestamp format or null + */ + function timestampOrNull( $ts = null ) { + if( is_null( $ts ) ) { + return null; + } else { + return $this->timestamp( $ts ); + } + } + + /** + * @todo document + */ + function resultObject( $result ) { + if( empty( $result ) ) { + return false; + } elseif ( $result instanceof ResultWrapper ) { + return $result; + } elseif ( $result === true ) { + // Successful write query + return $result; + } else { + return new ResultWrapper( $this, $result ); + } + } + + /** + * Return aggregated value alias + */ + function aggregateValue ($valuedata,$valuename='value') { + return $valuename; + } + + /** + * @return string wikitext of a link to the server software's web site + */ + function getSoftwareLink() { + return "[http://www.mysql.com/ MySQL]"; + } + + /** + * @return string Version information from the database + */ + function getServerVersion() { + return mysql_get_server_info( $this->mConn ); + } + + /** + * Ping the server and try to reconnect if it there is no connection + */ + function ping() { + if( !function_exists( 'mysql_ping' ) ) { + wfDebug( "Tried to call mysql_ping but this is ancient PHP version. Faking it!\n" ); + return true; + } + $ping = mysql_ping( $this->mConn ); + if ( $ping ) { + return true; + } + + // Need to reconnect manually in MySQL client 5.0.13+ + if ( version_compare( mysql_get_client_info(), '5.0.13', '>=' ) ) { + mysql_close( $this->mConn ); + $this->mOpened = false; + $this->mConn = false; + $this->open( $this->mServer, $this->mUser, $this->mPassword, $this->mDBname ); + return true; + } + return false; + } + + /** + * Get slave lag. + * At the moment, this will only work if the DB user has the PROCESS privilege + */ + function getLag() { + if ( !is_null( $this->mFakeSlaveLag ) ) { + wfDebug( "getLag: fake slave lagged {$this->mFakeSlaveLag} seconds\n" ); + return $this->mFakeSlaveLag; + } + $res = $this->query( 'SHOW PROCESSLIST' ); + # Find slave SQL thread + while ( $row = $this->fetchObject( $res ) ) { + /* This should work for most situations - when default db + * for thread is not specified, it had no events executed, + * and therefore it doesn't know yet how lagged it is. + * + * Relay log I/O thread does not select databases. + */ + if ( $row->User == 'system user' && + $row->State != 'Waiting for master to send event' && + $row->State != 'Connecting to master' && + $row->State != 'Queueing master event to the relay log' && + $row->State != 'Waiting for master update' && + $row->State != 'Requesting binlog dump' + ) { + # This is it, return the time (except -ve) + if ( $row->Time > 0x7fffffff ) { + return false; + } else { + return $row->Time; + } + } + } + return false; + } + + /** + * Get status information from SHOW STATUS in an associative array + */ + function getStatus($which="%") { + $res = $this->query( "SHOW STATUS LIKE '{$which}'" ); + $status = array(); + while ( $row = $this->fetchObject( $res ) ) { + $status[$row->Variable_name] = $row->Value; + } + return $status; + } + + /** + * Return the maximum number of items allowed in a list, or 0 for unlimited. + */ + function maxListLen() { + return 0; + } + + function encodeBlob($b) { + return $b; + } + + function decodeBlob($b) { + return $b; + } + + /** + * Override database's default connection timeout. + * May be useful for very long batch queries such as + * full-wiki dumps, where a single query reads out + * over hours or days. + * @param int $timeout in seconds + */ + public function setTimeout( $timeout ) { + $this->query( "SET net_read_timeout=$timeout" ); + $this->query( "SET net_write_timeout=$timeout" ); + } + + /** + * Read and execute SQL commands from a file. + * Returns true on success, error string or exception on failure (depending on object's error ignore settings) + * @param string $filename File name to open + * @param callback $lineCallback Optional function called before reading each line + * @param callback $resultCallback Optional function called for each MySQL result + */ + function sourceFile( $filename, $lineCallback = false, $resultCallback = false ) { + $fp = fopen( $filename, 'r' ); + if ( false === $fp ) { + throw new MWException( "Could not open \"{$filename}\".\n" ); + } + $error = $this->sourceStream( $fp, $lineCallback, $resultCallback ); + fclose( $fp ); + return $error; + } + + /** + * Read and execute commands from an open file handle + * Returns true on success, error string or exception on failure (depending on object's error ignore settings) + * @param string $fp File handle + * @param callback $lineCallback Optional function called before reading each line + * @param callback $resultCallback Optional function called for each MySQL result + */ + function sourceStream( $fp, $lineCallback = false, $resultCallback = false ) { + $cmd = ""; + $done = false; + $dollarquote = false; + + while ( ! feof( $fp ) ) { + if ( $lineCallback ) { + call_user_func( $lineCallback ); + } + $line = trim( fgets( $fp, 1024 ) ); + $sl = strlen( $line ) - 1; + + if ( $sl < 0 ) { continue; } + if ( '-' == $line{0} && '-' == $line{1} ) { continue; } + + ## Allow dollar quoting for function declarations + if (substr($line,0,4) == '$mw$') { + if ($dollarquote) { + $dollarquote = false; + $done = true; + } + else { + $dollarquote = true; + } + } + else if (!$dollarquote) { + if ( ';' == $line{$sl} && ($sl < 2 || ';' != $line{$sl - 1})) { + $done = true; + $line = substr( $line, 0, $sl ); + } + } + + if ( '' != $cmd ) { $cmd .= ' '; } + $cmd .= "$line\n"; + + if ( $done ) { + $cmd = str_replace(';;', ";", $cmd); + $cmd = $this->replaceVars( $cmd ); + $res = $this->query( $cmd, __METHOD__ ); + if ( $resultCallback ) { + call_user_func( $resultCallback, $res ); + } + + if ( false === $res ) { + $err = $this->lastError(); + return "Query \"{$cmd}\" failed with error code \"$err\".\n"; + } + + $cmd = ''; + $done = false; + } + } + return true; + } + + + /** + * Replace variables in sourced SQL + */ + protected function replaceVars( $ins ) { + $varnames = array( + 'wgDBserver', 'wgDBname', 'wgDBintlname', 'wgDBuser', + 'wgDBpassword', 'wgDBsqluser', 'wgDBsqlpassword', + 'wgDBadminuser', 'wgDBadminpassword', 'wgDBTableOptions', + ); + + // Ordinary variables + foreach ( $varnames as $var ) { + if( isset( $GLOBALS[$var] ) ) { + $val = addslashes( $GLOBALS[$var] ); // FIXME: safety check? + $ins = str_replace( '{$' . $var . '}', $val, $ins ); + $ins = str_replace( '/*$' . $var . '*/`', '`' . $val, $ins ); + $ins = str_replace( '/*$' . $var . '*/', $val, $ins ); + } + } + + // Table prefixes + $ins = preg_replace_callback( '/\/\*(?:\$wgDBprefix|_)\*\/([a-zA-Z_0-9]*)/', + array( &$this, 'tableNameCallback' ), $ins ); + return $ins; + } + + /** + * Table name callback + * @private + */ + protected function tableNameCallback( $matches ) { + return $this->tableName( $matches[1] ); + } + + /* + * Build a concatenation list to feed into a SQL query + */ + function buildConcat( $stringList ) { + return 'CONCAT(' . implode( ',', $stringList ) . ')'; + } + + /** + * Acquire a lock + * + * Abstracted from Filestore::lock() so child classes can implement for + * their own needs. + * + * @param string $lockName Name of lock to aquire + * @param string $method Name of method calling us + * @return bool + */ + public function lock( $lockName, $method ) { + $lockName = $this->addQuotes( $lockName ); + $result = $this->query( "SELECT GET_LOCK($lockName, 5) AS lockstatus", $method ); + $row = $this->fetchObject( $result ); + $this->freeResult( $result ); + + if( $row->lockstatus == 1 ) { + return true; + } else { + wfDebug( __METHOD__." failed to acquire lock\n" ); + return false; + } + } + /** + * Release a lock. + * + * @todo fixme - Figure out a way to return a bool + * based on successful lock release. + * + * @param string $lockName Name of lock to release + * @param string $method Name of method calling us + */ + public function unlock( $lockName, $method ) { + $lockName = $this->addQuotes( $lockName ); + $result = $this->query( "SELECT RELEASE_LOCK($lockName)", $method ); + $this->freeResult( $result ); + } +} + +/** + * Database abstraction object for mySQL + * Inherit all methods and properties of Database::Database() + * + * @ingroup Database + * @see Database + */ +class DatabaseMysql extends Database { + # Inherit all +} + +/****************************************************************************** + * Utility classes + *****************************************************************************/ + +/** + * Utility class. + * @ingroup Database + */ +class DBObject { + public $mData; + + function DBObject($data) { + $this->mData = $data; + } + + function isLOB() { + return false; + } + + function data() { + return $this->mData; + } +} + +/** + * Utility class + * @ingroup Database + * + * This allows us to distinguish a blob from a normal string and an array of strings + */ +class Blob { + private $mData; + function __construct($data) { + $this->mData = $data; + } + function fetch() { + return $this->mData; + } +} + +/** + * Utility class. + * @ingroup Database + */ +class MySQLField { + private $name, $tablename, $default, $max_length, $nullable, + $is_pk, $is_unique, $is_multiple, $is_key, $type; + function __construct ($info) { + $this->name = $info->name; + $this->tablename = $info->table; + $this->default = $info->def; + $this->max_length = $info->max_length; + $this->nullable = !$info->not_null; + $this->is_pk = $info->primary_key; + $this->is_unique = $info->unique_key; + $this->is_multiple = $info->multiple_key; + $this->is_key = ($this->is_pk || $this->is_unique || $this->is_multiple); + $this->type = $info->type; + } + + function name() { + return $this->name; + } + + function tableName() { + return $this->tableName; + } + + function defaultValue() { + return $this->default; + } + + function maxLength() { + return $this->max_length; + } + + function nullable() { + return $this->nullable; + } + + function isKey() { + return $this->is_key; + } + + function isMultipleKey() { + return $this->is_multiple; + } + + function type() { + return $this->type; + } +} + +/****************************************************************************** + * Error classes + *****************************************************************************/ + +/** + * Database error base class + * @ingroup Database + */ +class DBError extends MWException { + public $db; + + /** + * Construct a database error + * @param Database $db The database object which threw the error + * @param string $error A simple error message to be used for debugging + */ + function __construct( Database &$db, $error ) { + $this->db =& $db; + parent::__construct( $error ); + } +} + +/** + * @ingroup Database + */ +class DBConnectionError extends DBError { + public $error; + + function __construct( Database &$db, $error = 'unknown error' ) { + $msg = 'DB connection error'; + if ( trim( $error ) != '' ) { + $msg .= ": $error"; + } + $this->error = $error; + parent::__construct( $db, $msg ); + } + + function useOutputPage() { + // Not likely to work + return false; + } + + function useMessageCache() { + // Not likely to work + return false; + } + + function getText() { + return $this->getMessage() . "\n"; + } + + function getLogMessage() { + # Don't send to the exception log + return false; + } + + function getPageTitle() { + global $wgSitename; + return "$wgSitename has a problem"; + } + + function getHTML() { + global $wgTitle, $wgUseFileCache, $title, $wgInputEncoding; + global $wgSitename, $wgServer, $wgMessageCache; + + # I give up, Brion is right. Getting the message cache to work when there is no DB is tricky. + # Hard coding strings instead. + + $noconnect = "<p><strong>Sorry! This site is experiencing technical difficulties.</strong></p><p>Try waiting a few minutes and reloading.</p><p><small>(Can't contact the database server: $1)</small></p>"; + $mainpage = 'Main Page'; + $searchdisabled = <<<EOT +<p style="margin: 1.5em 2em 1em">$wgSitename search is disabled for performance reasons. You can search via Google in the meantime. +<span style="font-size: 89%; display: block; margin-left: .2em">Note that their indexes of $wgSitename content may be out of date.</span></p>', +EOT; + + $googlesearch = " +<!-- SiteSearch Google --> +<FORM method=GET action=\"http://www.google.com/search\"> +<TABLE bgcolor=\"#FFFFFF\"><tr><td> +<A HREF=\"http://www.google.com/\"> +<IMG SRC=\"http://www.google.com/logos/Logo_40wht.gif\" +border=\"0\" ALT=\"Google\"></A> +</td> +<td> +<INPUT TYPE=text name=q size=31 maxlength=255 value=\"$1\"> +<INPUT type=submit name=btnG VALUE=\"Google Search\"> +<font size=-1> +<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 /> +<input type='hidden' name='ie' value='$2'> +<input type='hidden' name='oe' value='$2'> +</font> +</td></tr></TABLE> +</FORM> +<!-- SiteSearch Google -->"; + $cachederror = "The following is a cached copy of the requested page, and may not be up to date. "; + + # No database access + if ( is_object( $wgMessageCache ) ) { + $wgMessageCache->disable(); + } + + if ( trim( $this->error ) == '' ) { + $this->error = $this->db->getProperty('mServer'); + } + + $text = str_replace( '$1', $this->error, $noconnect ); + $text .= wfGetSiteNotice(); + + if($wgUseFileCache) { + if($wgTitle) { + $t =& $wgTitle; + } else { + if($title) { + $t = Title::newFromURL( $title ); + } elseif (@/**/$_REQUEST['search']) { + $search = $_REQUEST['search']; + return $searchdisabled . + str_replace( array( '$1', '$2' ), array( htmlspecialchars( $search ), + $wgInputEncoding ), $googlesearch ); + } else { + $t = Title::newFromText( $mainpage ); + } + } + + $cache = new HTMLFileCache( $t ); + if( $cache->isFileCached() ) { + // @todo, FIXME: $msg is not defined on the next line. + $msg = '<p style="color: red"><b>'.$msg."<br />\n" . + $cachederror . "</b></p>\n"; + + $tag = '<div id="article">'; + $text = str_replace( + $tag, + $tag . $msg, + $cache->fetchPageText() ); + } + } + + return $text; + } +} + +/** + * @ingroup Database + */ +class DBQueryError extends DBError { + public $error, $errno, $sql, $fname; + + function __construct( Database &$db, $error, $errno, $sql, $fname ) { + $message = "A database error has occurred\n" . + "Query: $sql\n" . + "Function: $fname\n" . + "Error: $errno $error\n"; + + parent::__construct( $db, $message ); + $this->error = $error; + $this->errno = $errno; + $this->sql = $sql; + $this->fname = $fname; + } + + function getText() { + if ( $this->useMessageCache() ) { + return wfMsg( 'dberrortextcl', htmlspecialchars( $this->getSQL() ), + htmlspecialchars( $this->fname ), $this->errno, htmlspecialchars( $this->error ) ) . "\n"; + } else { + return $this->getMessage(); + } + } + + function getSQL() { + global $wgShowSQLErrors; + if( !$wgShowSQLErrors ) { + return $this->msg( 'sqlhidden', 'SQL hidden' ); + } else { + return $this->sql; + } + } + + function getLogMessage() { + # Don't send to the exception log + return false; + } + + function getPageTitle() { + return $this->msg( 'databaseerror', 'Database error' ); + } + + function getHTML() { + if ( $this->useMessageCache() ) { + return wfMsgNoDB( 'dberrortext', htmlspecialchars( $this->getSQL() ), + htmlspecialchars( $this->fname ), $this->errno, htmlspecialchars( $this->error ) ); + } else { + return nl2br( htmlspecialchars( $this->getMessage() ) ); + } + } +} + +/** + * @ingroup Database + */ +class DBUnexpectedError extends DBError {} + + +/** + * Result wrapper for grabbing data queried by someone else + * @ingroup Database + */ +class ResultWrapper implements Iterator { + var $db, $result, $pos = 0, $currentRow = null; + + /** + * Create a new result object from a result resource and a Database object + */ + function ResultWrapper( $database, $result ) { + $this->db = $database; + if ( $result instanceof ResultWrapper ) { + $this->result = $result->result; + } else { + $this->result = $result; + } + } + + /** + * Get the number of rows in a result object + */ + function numRows() { + return $this->db->numRows( $this->result ); + } + + /** + * Fetch the next row from the given result object, in object form. + * Fields can be retrieved with $row->fieldname, with fields acting like + * member variables. + * + * @param $res SQL result object as returned from Database::query(), etc. + * @return MySQL row object + * @throws DBUnexpectedError Thrown if the database returns an error + */ + function fetchObject() { + return $this->db->fetchObject( $this->result ); + } + + /** + * Fetch the next row from the given result object, in associative array + * form. Fields are retrieved with $row['fieldname']. + * + * @param $res SQL result object as returned from Database::query(), etc. + * @return MySQL row object + * @throws DBUnexpectedError Thrown if the database returns an error + */ + function fetchRow() { + return $this->db->fetchRow( $this->result ); + } + + /** + * Free a result object + */ + function free() { + $this->db->freeResult( $this->result ); + unset( $this->result ); + unset( $this->db ); + } + + /** + * Change the position of the cursor in a result object + * See mysql_data_seek() + */ + function seek( $row ) { + $this->db->dataSeek( $this->result, $row ); + } + + /********************* + * Iterator functions + * Note that using these in combination with the non-iterator functions + * above may cause rows to be skipped or repeated. + */ + + function rewind() { + if ($this->numRows()) { + $this->db->dataSeek($this->result, 0); + } + $this->pos = 0; + $this->currentRow = null; + } + + function current() { + if ( is_null( $this->currentRow ) ) { + $this->next(); + } + return $this->currentRow; + } + + function key() { + return $this->pos; + } + + function next() { + $this->pos++; + $this->currentRow = $this->fetchObject(); + return $this->currentRow; + } + + function valid() { + return $this->current() !== false; + } +} + +class MySQLMasterPos { + var $file, $pos; + + function __construct( $file, $pos ) { + $this->file = $file; + $this->pos = $pos; + } + + function __toString() { + return "{$this->file}/{$this->pos}"; + } +} diff --git a/includes/db/DatabaseMssql.php b/includes/db/DatabaseMssql.php new file mode 100644 index 00000000..32fe28b1 --- /dev/null +++ b/includes/db/DatabaseMssql.php @@ -0,0 +1,1029 @@ +<?php +/** + * This script is the MSSQL Server database abstraction layer + * + * See maintenance/mssql/README for development notes and other specific information + * @ingroup Database + * @file + */ + +/** + * @ingroup Database + */ +class DatabaseMssql extends Database { + + var $mAffectedRows; + var $mLastResult; + var $mLastError; + var $mLastErrorNo; + var $mDatabaseFile; + + /** + * Constructor + */ + function __construct($server = false, $user = false, $password = false, $dbName = false, + $failFunction = false, $flags = 0, $tablePrefix = 'get from global') { + + global $wgOut, $wgDBprefix, $wgCommandLineMode; + if (!isset($wgOut)) $wgOut = NULL; # Can't get a reference if it hasn't been set yet + $this->mOut =& $wgOut; + $this->mFailFunction = $failFunction; + $this->mFlags = $flags; + + if ( $this->mFlags & DBO_DEFAULT ) { + if ( $wgCommandLineMode ) { + $this->mFlags &= ~DBO_TRX; + } else { + $this->mFlags |= DBO_TRX; + } + } + + /** Get the default table prefix*/ + $this->mTablePrefix = $tablePrefix == 'get from global' ? $wgDBprefix : $tablePrefix; + + if ($server) $this->open($server, $user, $password, $dbName); + + } + + /** + * todo: check if these should be true like parent class + */ + function implicitGroupby() { return false; } + function implicitOrderby() { return false; } + + static function newFromParams($server, $user, $password, $dbName, $failFunction = false, $flags = 0) { + return new DatabaseMssql($server, $user, $password, $dbName, $failFunction, $flags); + } + + /** Open an MSSQL database and return a resource handle to it + * NOTE: only $dbName is used, the other parameters are irrelevant for MSSQL databases + */ + function open($server,$user,$password,$dbName) { + wfProfileIn(__METHOD__); + + # Test for missing mysql.so + # First try to load it + if (!@extension_loaded('mssql')) { + @dl('mssql.so'); + } + + # Fail now + # Otherwise we get a suppressed fatal error, which is very hard to track down + if (!function_exists( 'mssql_connect')) { + throw new DBConnectionError( $this, "MSSQL functions missing, have you compiled PHP with the --with-mssql option?\n" ); + } + + $this->close(); + $this->mServer = $server; + $this->mUser = $user; + $this->mPassword = $password; + $this->mDBname = $dbName; + + wfProfileIn("dbconnect-$server"); + + # Try to connect up to three times + # The kernel's default SYN retransmission period is far too slow for us, + # so we use a short timeout plus a manual retry. + $this->mConn = false; + $max = 3; + for ( $i = 0; $i < $max && !$this->mConn; $i++ ) { + if ( $i > 1 ) { + usleep( 1000 ); + } + if ($this->mFlags & DBO_PERSISTENT) { + @/**/$this->mConn = mssql_pconnect($server, $user, $password); + } else { + # Create a new connection... + @/**/$this->mConn = mssql_connect($server, $user, $password, true); + } + } + + wfProfileOut("dbconnect-$server"); + + if ($dbName != '') { + if ($this->mConn !== false) { + $success = @/**/mssql_select_db($dbName, $this->mConn); + if (!$success) { + $error = "Error selecting database $dbName on server {$this->mServer} " . + "from client host {$wguname['nodename']}\n"; + wfLogDBError(" Error selecting database $dbName on server {$this->mServer} \n"); + wfDebug( $error ); + } + } else { + wfDebug("DB connection error\n"); + wfDebug("Server: $server, User: $user, Password: ".substr($password, 0, 3)."...\n"); + $success = false; + } + } else { + # Delay USE query + $success = (bool)$this->mConn; + } + + if (!$success) $this->reportConnectionError(); + $this->mOpened = $success; + wfProfileOut(__METHOD__); + return $success; + } + + /** + * Close an MSSQL database + */ + function close() { + $this->mOpened = false; + if ($this->mConn) { + if ($this->trxLevel()) $this->immediateCommit(); + return mssql_close($this->mConn); + } else return true; + } + + /** + * - MSSQL doesn't seem to do buffered results + * - the trasnaction syntax is modified here to avoid having to replicate + * Database::query which uses BEGIN, COMMIT, ROLLBACK + */ + function doQuery($sql) { + if ($sql == 'BEGIN' || $sql == 'COMMIT' || $sql == 'ROLLBACK') return true; # $sql .= ' TRANSACTION'; + $sql = preg_replace('|[^\x07-\x7e]|','?',$sql); # TODO: need to fix unicode - just removing it here while testing + $ret = mssql_query($sql, $this->mConn); + if ($ret === false) { + $err = mssql_get_last_message(); + if ($err) $this->mlastError = $err; + $row = mssql_fetch_row(mssql_query('select @@ERROR')); + if ($row[0]) $this->mlastErrorNo = $row[0]; + } else $this->mlastErrorNo = false; + return $ret; + } + + /**#@+ + * @param mixed $res A SQL result + */ + /** + * Free a result object + */ + function freeResult( $res ) { + if ( $res instanceof ResultWrapper ) { + $res = $res->result; + } + if ( !@/**/mssql_free_result( $res ) ) { + throw new DBUnexpectedError( $this, "Unable to free MSSQL result" ); + } + } + + /** + * Fetch the next row from the given result object, in object form. + * Fields can be retrieved with $row->fieldname, with fields acting like + * member variables. + * + * @param $res SQL result object as returned from Database::query(), etc. + * @return MySQL row object + * @throws DBUnexpectedError Thrown if the database returns an error + */ + function fetchObject( $res ) { + if ( $res instanceof ResultWrapper ) { + $res = $res->result; + } + @/**/$row = mssql_fetch_object( $res ); + if ( $this->lastErrno() ) { + throw new DBUnexpectedError( $this, 'Error in fetchObject(): ' . htmlspecialchars( $this->lastError() ) ); + } + return $row; + } + + /** + * Fetch the next row from the given result object, in associative array + * form. Fields are retrieved with $row['fieldname']. + * + * @param $res SQL result object as returned from Database::query(), etc. + * @return MySQL row object + * @throws DBUnexpectedError Thrown if the database returns an error + */ + function fetchRow( $res ) { + if ( $res instanceof ResultWrapper ) { + $res = $res->result; + } + @/**/$row = mssql_fetch_array( $res ); + if ( $this->lastErrno() ) { + throw new DBUnexpectedError( $this, 'Error in fetchRow(): ' . htmlspecialchars( $this->lastError() ) ); + } + return $row; + } + + /** + * Get the number of rows in a result object + */ + function numRows( $res ) { + if ( $res instanceof ResultWrapper ) { + $res = $res->result; + } + @/**/$n = mssql_num_rows( $res ); + if ( $this->lastErrno() ) { + throw new DBUnexpectedError( $this, 'Error in numRows(): ' . htmlspecialchars( $this->lastError() ) ); + } + return $n; + } + + /** + * Get the number of fields in a result object + * See documentation for mysql_num_fields() + */ + function numFields( $res ) { + if ( $res instanceof ResultWrapper ) { + $res = $res->result; + } + return mssql_num_fields( $res ); + } + + /** + * Get a field name in a result object + * See documentation for mysql_field_name(): + * http://www.php.net/mysql_field_name + */ + function fieldName( $res, $n ) { + if ( $res instanceof ResultWrapper ) { + $res = $res->result; + } + return mssql_field_name( $res, $n ); + } + + /** + * Get the inserted value of an auto-increment row + * + * The value inserted should be fetched from nextSequenceValue() + * + * Example: + * $id = $dbw->nextSequenceValue('page_page_id_seq'); + * $dbw->insert('page',array('page_id' => $id)); + * $id = $dbw->insertId(); + */ + function insertId() { + $row = mssql_fetch_row(mssql_query('select @@IDENTITY')); + return $row[0]; + } + + /** + * Change the position of the cursor in a result object + * See mysql_data_seek() + */ + function dataSeek( $res, $row ) { + if ( $res instanceof ResultWrapper ) { + $res = $res->result; + } + return mssql_data_seek( $res, $row ); + } + + /** + * Get the last error number + */ + function lastErrno() { + return $this->mlastErrorNo; + } + + /** + * Get a description of the last error + */ + function lastError() { + return $this->mlastError; + } + + /** + * Get the number of rows affected by the last write query + */ + function affectedRows() { + return mssql_rows_affected( $this->mConn ); + } + + /** + * Simple UPDATE wrapper + * Usually aborts on failure + * If errors are explicitly ignored, returns success + * + * This function exists for historical reasons, Database::update() has a more standard + * calling convention and feature set + */ + function set( $table, $var, $value, $cond, $fname = 'Database::set' ) + { + if ($value == "NULL") $value = "''"; # see comments in makeListWithoutNulls() + $table = $this->tableName( $table ); + $sql = "UPDATE $table SET $var = '" . + $this->strencode( $value ) . "' WHERE ($cond)"; + return (bool)$this->query( $sql, $fname ); + } + + /** + * Simple SELECT wrapper, returns a single field, input must be encoded + * Usually aborts on failure + * If errors are explicitly ignored, returns FALSE on failure + */ + function selectField( $table, $var, $cond='', $fname = 'Database::selectField', $options = array() ) { + if ( !is_array( $options ) ) { + $options = array( $options ); + } + $options['LIMIT'] = 1; + + $res = $this->select( $table, $var, $cond, $fname, $options ); + if ( $res === false || !$this->numRows( $res ) ) { + return false; + } + $row = $this->fetchRow( $res ); + if ( $row !== false ) { + $this->freeResult( $res ); + return $row[0]; + } else { + return false; + } + } + + /** + * Returns an optional USE INDEX clause to go after the table, and a + * string to go at the end of the query + * + * @private + * + * @param array $options an associative array of options to be turned into + * an SQL query, valid keys are listed in the function. + * @return array + */ + function makeSelectOptions( $options ) { + $preLimitTail = $postLimitTail = ''; + $startOpts = ''; + + $noKeyOptions = array(); + foreach ( $options as $key => $option ) { + if ( is_numeric( $key ) ) { + $noKeyOptions[$option] = true; + } + } + + if ( isset( $options['GROUP BY'] ) ) $preLimitTail .= " GROUP BY {$options['GROUP BY']}"; + if ( isset( $options['HAVING'] ) ) $preLimitTail .= " HAVING {$options['HAVING']}"; + if ( isset( $options['ORDER BY'] ) ) $preLimitTail .= " ORDER BY {$options['ORDER BY']}"; + + //if (isset($options['LIMIT'])) { + // $tailOpts .= $this->limitResult('', $options['LIMIT'], + // isset($options['OFFSET']) ? $options['OFFSET'] + // : false); + //} + + if ( isset( $noKeyOptions['FOR UPDATE'] ) ) $postLimitTail .= ' FOR UPDATE'; + if ( isset( $noKeyOptions['LOCK IN SHARE MODE'] ) ) $postLimitTail .= ' LOCK IN SHARE MODE'; + if ( isset( $noKeyOptions['DISTINCT'] ) || isset( $noKeyOptions['DISTINCTROW'] ) ) $startOpts .= 'DISTINCT'; + + # Various MySQL extensions + if ( isset( $noKeyOptions['STRAIGHT_JOIN'] ) ) $startOpts .= ' /*! STRAIGHT_JOIN */'; + if ( isset( $noKeyOptions['HIGH_PRIORITY'] ) ) $startOpts .= ' HIGH_PRIORITY'; + if ( isset( $noKeyOptions['SQL_BIG_RESULT'] ) ) $startOpts .= ' SQL_BIG_RESULT'; + if ( isset( $noKeyOptions['SQL_BUFFER_RESULT'] ) ) $startOpts .= ' SQL_BUFFER_RESULT'; + if ( isset( $noKeyOptions['SQL_SMALL_RESULT'] ) ) $startOpts .= ' SQL_SMALL_RESULT'; + if ( isset( $noKeyOptions['SQL_CALC_FOUND_ROWS'] ) ) $startOpts .= ' SQL_CALC_FOUND_ROWS'; + if ( isset( $noKeyOptions['SQL_CACHE'] ) ) $startOpts .= ' SQL_CACHE'; + if ( isset( $noKeyOptions['SQL_NO_CACHE'] ) ) $startOpts .= ' SQL_NO_CACHE'; + + if ( isset( $options['USE INDEX'] ) && ! is_array( $options['USE INDEX'] ) ) { + $useIndex = $this->useIndexClause( $options['USE INDEX'] ); + } else { + $useIndex = ''; + } + + return array( $startOpts, $useIndex, $preLimitTail, $postLimitTail ); + } + + /** + * SELECT wrapper + * + * @param mixed $table Array or string, table name(s) (prefix auto-added) + * @param mixed $vars Array or string, field name(s) to be retrieved + * @param mixed $conds Array or string, condition(s) for WHERE + * @param string $fname Calling function name (use __METHOD__) for logs/profiling + * @param array $options Associative array of options (e.g. array('GROUP BY' => 'page_title')), + * see Database::makeSelectOptions code for list of supported stuff + * @return mixed Database result resource (feed to Database::fetchObject or whatever), or false on failure + */ + function select( $table, $vars, $conds='', $fname = 'Database::select', $options = array() ) + { + if( is_array( $vars ) ) { + $vars = implode( ',', $vars ); + } + if( !is_array( $options ) ) { + $options = array( $options ); + } + if( is_array( $table ) ) { + if ( isset( $options['USE INDEX'] ) && is_array( $options['USE INDEX'] ) ) + $from = ' FROM ' . $this->tableNamesWithUseIndex( $table, $options['USE INDEX'] ); + else + $from = ' FROM ' . implode( ',', array_map( array( &$this, 'tableName' ), $table ) ); + } elseif ($table!='') { + if ($table{0}==' ') { + $from = ' FROM ' . $table; + } else { + $from = ' FROM ' . $this->tableName( $table ); + } + } else { + $from = ''; + } + + list( $startOpts, $useIndex, $preLimitTail, $postLimitTail ) = $this->makeSelectOptions( $options ); + + if( !empty( $conds ) ) { + if ( is_array( $conds ) ) { + $conds = $this->makeList( $conds, LIST_AND ); + } + $sql = "SELECT $startOpts $vars $from $useIndex WHERE $conds $preLimitTail"; + } else { + $sql = "SELECT $startOpts $vars $from $useIndex $preLimitTail"; + } + + if (isset($options['LIMIT'])) + $sql = $this->limitResult($sql, $options['LIMIT'], + isset($options['OFFSET']) ? $options['OFFSET'] : false); + $sql = "$sql $postLimitTail"; + + if (isset($options['EXPLAIN'])) { + $sql = 'EXPLAIN ' . $sql; + } + return $this->query( $sql, $fname ); + } + + /** + * Estimate rows in dataset + * Returns estimated count, based on EXPLAIN output + * Takes same arguments as Database::select() + */ + function estimateRowCount( $table, $vars='*', $conds='', $fname = 'Database::estimateRowCount', $options = array() ) { + $rows = 0; + $res = $this->select ($table, 'COUNT(*)', $conds, $fname, $options ); + if ($res) { + $row = $this->fetchObject($res); + $rows = $row[0]; + } + $this->freeResult($res); + return $rows; + } + + /** + * Determines whether a field exists in a table + * Usually aborts on failure + * If errors are explicitly ignored, returns NULL on failure + */ + function fieldExists( $table, $field, $fname = 'Database::fieldExists' ) { + $table = $this->tableName( $table ); + $sql = "SELECT TOP 1 * FROM $table"; + $res = $this->query( $sql, 'Database::fieldExists' ); + + $found = false; + while ( $row = $this->fetchArray( $res ) ) { + if ( isset($row[$field]) ) { + $found = true; + break; + } + } + + $this->freeResult( $res ); + return $found; + } + + /** + * Get information about an index into an object + * Returns false if the index does not exist + */ + function indexInfo( $table, $index, $fname = 'Database::indexInfo' ) { + + throw new DBUnexpectedError( $this, 'Database::indexInfo called which is not supported yet' ); + return NULL; + + $table = $this->tableName( $table ); + $sql = 'SHOW INDEX FROM '.$table; + $res = $this->query( $sql, $fname ); + if ( !$res ) { + return NULL; + } + + $result = array(); + while ( $row = $this->fetchObject( $res ) ) { + if ( $row->Key_name == $index ) { + $result[] = $row; + } + } + $this->freeResult($res); + + return empty($result) ? false : $result; + } + + /** + * Query whether a given table exists + */ + function tableExists( $table ) { + $table = $this->tableName( $table ); + $res = $this->query( "SELECT * FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_NAME = '$table'" ); + $exist = ($res->numRows() > 0); + $this->freeResult($res); + return $exist; + } + + /** + * mysql_fetch_field() wrapper + * Returns false if the field doesn't exist + * + * @param $table + * @param $field + */ + function fieldInfo( $table, $field ) { + $table = $this->tableName( $table ); + $res = $this->query( "SELECT TOP 1 * FROM $table" ); + $n = mssql_num_fields( $res->result ); + for( $i = 0; $i < $n; $i++ ) { + $meta = mssql_fetch_field( $res->result, $i ); + if( $field == $meta->name ) { + return new MSSQLField($meta); + } + } + return false; + } + + /** + * mysql_field_type() wrapper + */ + function fieldType( $res, $index ) { + if ( $res instanceof ResultWrapper ) { + $res = $res->result; + } + return mssql_field_type( $res, $index ); + } + + /** + * INSERT wrapper, inserts an array into a table + * + * $a may be a single associative array, or an array of these with numeric keys, for + * multi-row insert. + * + * Usually aborts on failure + * If errors are explicitly ignored, returns success + * + * Same as parent class implementation except that it removes primary key from column lists + * because MSSQL doesn't support writing nulls to IDENTITY (AUTO_INCREMENT) columns + */ + function insert( $table, $a, $fname = 'Database::insert', $options = array() ) { + # No rows to insert, easy just return now + if ( !count( $a ) ) { + return true; + } + $table = $this->tableName( $table ); + if ( !is_array( $options ) ) { + $options = array( $options ); + } + + # todo: need to record primary keys at table create time, and remove NULL assignments to them + if ( isset( $a[0] ) && is_array( $a[0] ) ) { + $multi = true; + $keys = array_keys( $a[0] ); +# if (ereg('_id$',$keys[0])) { + foreach ($a as $i) { + if (is_null($i[$keys[0]])) unset($i[$keys[0]]); # remove primary-key column from multiple insert lists if empty value + } +# } + $keys = array_keys( $a[0] ); + } else { + $multi = false; + $keys = array_keys( $a ); +# if (ereg('_id$',$keys[0]) && empty($a[$keys[0]])) unset($a[$keys[0]]); # remove primary-key column from insert list if empty value + if (is_null($a[$keys[0]])) unset($a[$keys[0]]); # remove primary-key column from insert list if empty value + $keys = array_keys( $a ); + } + + # handle IGNORE option + # example: + # MySQL: INSERT IGNORE INTO user_groups (ug_user,ug_group) VALUES ('1','sysop') + # MSSQL: IF NOT EXISTS (SELECT * FROM user_groups WHERE ug_user = '1') INSERT INTO user_groups (ug_user,ug_group) VALUES ('1','sysop') + $ignore = in_array('IGNORE',$options); + + # remove IGNORE from options list + if ($ignore) { + $oldoptions = $options; + $options = array(); + foreach ($oldoptions as $o) if ($o != 'IGNORE') $options[] = $o; + } + + $keylist = implode(',', $keys); + $sql = 'INSERT '.implode(' ', $options)." INTO $table (".implode(',', $keys).') VALUES '; + if ($multi) { + if ($ignore) { + # If multiple and ignore, then do each row as a separate conditional insert + foreach ($a as $row) { + $prival = $row[$keys[0]]; + $sql = "IF NOT EXISTS (SELECT * FROM $table WHERE $keys[0] = '$prival') $sql"; + if (!$this->query("$sql (".$this->makeListWithoutNulls($row).')', $fname)) return false; + } + return true; + } else { + $first = true; + foreach ($a as $row) { + if ($first) $first = false; else $sql .= ','; + $sql .= '('.$this->makeListWithoutNulls($row).')'; + } + } + } else { + if ($ignore) { + $prival = $a[$keys[0]]; + $sql = "IF NOT EXISTS (SELECT * FROM $table WHERE $keys[0] = '$prival') $sql"; + } + $sql .= '('.$this->makeListWithoutNulls($a).')'; + } + return (bool)$this->query( $sql, $fname ); + } + + /** + * MSSQL doesn't allow implicit casting of NULL's into non-null values for NOT NULL columns + * for now I've just converted the NULL's in the lists for updates and inserts into empty strings + * which get implicitly casted to 0 for numeric columns + * NOTE: the set() method above converts NULL to empty string as well but not via this method + */ + function makeListWithoutNulls($a, $mode = LIST_COMMA) { + return str_replace("NULL","''",$this->makeList($a,$mode)); + } + + /** + * UPDATE wrapper, takes a condition array and a SET array + * + * @param string $table The table to UPDATE + * @param array $values An array of values to SET + * @param array $conds An array of conditions (WHERE). Use '*' to update all rows. + * @param string $fname The Class::Function calling this function + * (for the log) + * @param array $options An array of UPDATE options, can be one or + * more of IGNORE, LOW_PRIORITY + * @return bool + */ + function update( $table, $values, $conds, $fname = 'Database::update', $options = array() ) { + $table = $this->tableName( $table ); + $opts = $this->makeUpdateOptions( $options ); + $sql = "UPDATE $opts $table SET " . $this->makeListWithoutNulls( $values, LIST_SET ); + if ( $conds != '*' ) { + $sql .= " WHERE " . $this->makeList( $conds, LIST_AND ); + } + return $this->query( $sql, $fname ); + } + + /** + * Make UPDATE options for the Database::update function + * + * @private + * @param array $options The options passed to Database::update + * @return string + */ + function makeUpdateOptions( $options ) { + if( !is_array( $options ) ) { + $options = array( $options ); + } + $opts = array(); + if ( in_array( 'LOW_PRIORITY', $options ) ) + $opts[] = $this->lowPriorityOption(); + if ( in_array( 'IGNORE', $options ) ) + $opts[] = 'IGNORE'; + return implode(' ', $opts); + } + + /** + * Change the current database + */ + function selectDB( $db ) { + $this->mDBname = $db; + return mssql_select_db( $db, $this->mConn ); + } + + /** + * MSSQL has a problem with the backtick quoting, so all this does is ensure the prefix is added exactly once + */ + function tableName($name) { + return strpos($name, $this->mTablePrefix) === 0 ? $name : "{$this->mTablePrefix}$name"; + } + + /** + * MSSQL doubles quotes instead of escaping them + * @param string $s String to be slashed. + * @return string slashed string. + */ + function strencode($s) { + return str_replace("'","''",$s); + } + + /** + * USE INDEX clause + */ + function useIndexClause( $index ) { + return ""; + } + + /** + * REPLACE query wrapper + * PostgreSQL simulates this with a DELETE followed by INSERT + * $row is the row to insert, an associative array + * $uniqueIndexes is an array of indexes. Each element may be either a + * field name or an array of field names + * + * It may be more efficient to leave off unique indexes which are unlikely to collide. + * However if you do this, you run the risk of encountering errors which wouldn't have + * occurred in MySQL + * + * @todo migrate comment to phodocumentor format + */ + function replace( $table, $uniqueIndexes, $rows, $fname = 'Database::replace' ) { + $table = $this->tableName( $table ); + + # Single row case + if ( !is_array( reset( $rows ) ) ) { + $rows = array( $rows ); + } + + $sql = "REPLACE INTO $table (" . implode( ',', array_keys( $rows[0] ) ) .') VALUES '; + $first = true; + foreach ( $rows as $row ) { + if ( $first ) { + $first = false; + } else { + $sql .= ','; + } + $sql .= '(' . $this->makeList( $row ) . ')'; + } + return $this->query( $sql, $fname ); + } + + /** + * DELETE where the condition is a join + * MySQL does this with a multi-table DELETE syntax, PostgreSQL does it with sub-selects + * + * For safety, an empty $conds will not delete everything. If you want to delete all rows where the + * join condition matches, set $conds='*' + * + * DO NOT put the join condition in $conds + * + * @param string $delTable The table to delete from. + * @param string $joinTable The other table. + * @param string $delVar The variable to join on, in the first table. + * @param string $joinVar The variable to join on, in the second table. + * @param array $conds Condition array of field names mapped to variables, ANDed together in the WHERE clause + */ + function deleteJoin( $delTable, $joinTable, $delVar, $joinVar, $conds, $fname = 'Database::deleteJoin' ) { + if ( !$conds ) { + throw new DBUnexpectedError( $this, 'Database::deleteJoin() called with empty $conds' ); + } + + $delTable = $this->tableName( $delTable ); + $joinTable = $this->tableName( $joinTable ); + $sql = "DELETE $delTable FROM $delTable, $joinTable WHERE $delVar=$joinVar "; + if ( $conds != '*' ) { + $sql .= ' AND ' . $this->makeList( $conds, LIST_AND ); + } + + return $this->query( $sql, $fname ); + } + + /** + * Returns the size of a text field, or -1 for "unlimited" + */ + function textFieldSize( $table, $field ) { + $table = $this->tableName( $table ); + $sql = "SELECT TOP 1 * FROM $table;"; + $res = $this->query( $sql, 'Database::textFieldSize' ); + $row = $this->fetchObject( $res ); + $this->freeResult( $res ); + + $m = array(); + if ( preg_match( '/\((.*)\)/', $row->Type, $m ) ) { + $size = $m[1]; + } else { + $size = -1; + } + return $size; + } + + /** + * @return string Returns the text of the low priority option if it is supported, or a blank string otherwise + */ + function lowPriorityOption() { + return 'LOW_PRIORITY'; + } + + /** + * INSERT SELECT wrapper + * $varMap must be an associative array of the form array( 'dest1' => 'source1', ...) + * Source items may be literals rather than field names, but strings should be quoted with Database::addQuotes() + * $conds may be "*" to copy the whole table + * srcTable may be an array of tables. + */ + function insertSelect( $destTable, $srcTable, $varMap, $conds, $fname = 'Database::insertSelect', + $insertOptions = array(), $selectOptions = array() ) + { + $destTable = $this->tableName( $destTable ); + if ( is_array( $insertOptions ) ) { + $insertOptions = implode( ' ', $insertOptions ); + } + if( !is_array( $selectOptions ) ) { + $selectOptions = array( $selectOptions ); + } + list( $startOpts, $useIndex, $tailOpts ) = $this->makeSelectOptions( $selectOptions ); + if( is_array( $srcTable ) ) { + $srcTable = implode( ',', array_map( array( &$this, 'tableName' ), $srcTable ) ); + } else { + $srcTable = $this->tableName( $srcTable ); + } + $sql = "INSERT $insertOptions INTO $destTable (" . implode( ',', array_keys( $varMap ) ) . ')' . + " SELECT $startOpts " . implode( ',', $varMap ) . + " FROM $srcTable $useIndex "; + if ( $conds != '*' ) { + $sql .= ' WHERE ' . $this->makeList( $conds, LIST_AND ); + } + $sql .= " $tailOpts"; + return $this->query( $sql, $fname ); + } + + /** + * Construct a LIMIT query with optional offset + * This is used for query pages + * $sql string SQL query we will append the limit to + * $limit integer the SQL limit + * $offset integer the SQL offset (default false) + */ + function limitResult($sql, $limit, $offset=false) { + if( !is_numeric($limit) ) { + throw new DBUnexpectedError( $this, "Invalid non-numeric limit passed to limitResult()\n" ); + } + if ($offset) { + throw new DBUnexpectedError( $this, 'Database::limitResult called with non-zero offset which is not supported yet' ); + } else { + $sql = ereg_replace("^SELECT", "SELECT TOP $limit", $sql); + } + return $sql; + } + + /** + * Returns an SQL expression for a simple conditional. + * + * @param string $cond SQL expression which will result in a boolean value + * @param string $trueVal SQL expression to return if true + * @param string $falseVal SQL expression to return if false + * @return string SQL fragment + */ + function conditional( $cond, $trueVal, $falseVal ) { + return " (CASE WHEN $cond THEN $trueVal ELSE $falseVal END) "; + } + + /** + * Should determine if the last failure was due to a deadlock + * @return bool + */ + function wasDeadlock() { + return $this->lastErrno() == 1205; + } + + /** + * Begin a transaction, committing any previously open transaction + * @deprecated use begin() + */ + function immediateBegin( $fname = 'Database::immediateBegin' ) { + $this->begin(); + } + + /** + * Commit transaction, if one is open + * @deprecated use commit() + */ + function immediateCommit( $fname = 'Database::immediateCommit' ) { + $this->commit(); + } + + /** + * Return MW-style timestamp used for MySQL schema + */ + function timestamp( $ts=0 ) { + return wfTimestamp(TS_MW,$ts); + } + + /** + * Local database timestamp format or null + */ + function timestampOrNull( $ts = null ) { + if( is_null( $ts ) ) { + return null; + } else { + return $this->timestamp( $ts ); + } + } + + /** + * @return string wikitext of a link to the server software's web site + */ + function getSoftwareLink() { + return "[http://www.microsoft.com/sql/default.mspx Microsoft SQL Server 2005 Home]"; + } + + /** + * @return string Version information from the database + */ + function getServerVersion() { + $row = mssql_fetch_row(mssql_query('select @@VERSION')); + return ereg("^(.+[0-9]+\\.[0-9]+\\.[0-9]+) ",$row[0],$m) ? $m[1] : $row[0]; + } + + function limitResultForUpdate($sql, $num) { + return $sql; + } + + /** + * not done + */ + public function setTimeout($timeout) { return; } + + function ping() { + wfDebug("Function ping() not written for MSSQL yet"); + return true; + } + + /** + * How lagged is this slave? + */ + public function getLag() { + return 0; + } + + /** + * Called by the installer script + * - this is the same way as DatabasePostgresql.php, MySQL reads in tables.sql and interwiki.sql using dbsource (which calls db->sourceFile) + */ + public function setup_database() { + global $IP,$wgDBTableOptions; + $wgDBTableOptions = ''; + $mysql_tmpl = "$IP/maintenance/tables.sql"; + $mysql_iw = "$IP/maintenance/interwiki.sql"; + $mssql_tmpl = "$IP/maintenance/mssql/tables.sql"; + + # Make an MSSQL template file if it doesn't exist (based on the same one MySQL uses to create a new wiki db) + if (!file_exists($mssql_tmpl)) { # todo: make this conditional again + $sql = file_get_contents($mysql_tmpl); + $sql = preg_replace('/^\s*--.*?$/m','',$sql); # strip comments + $sql = preg_replace('/^\s*(UNIQUE )?(INDEX|KEY|FULLTEXT).+?$/m', '', $sql); # These indexes should be created with a CREATE INDEX query + $sql = preg_replace('/(\sKEY) [^\(]+\(/is', '$1 (', $sql); # "KEY foo (foo)" should just be "KEY (foo)" + $sql = preg_replace('/(varchar\([0-9]+\))\s+binary/i', '$1', $sql); # "varchar(n) binary" cannot be followed by "binary" + $sql = preg_replace('/(var)?binary\(([0-9]+)\)/ie', '"varchar(".strlen(pow(2,$2)).")"', $sql); # use varchar(chars) not binary(bits) + $sql = preg_replace('/ (var)?binary/i', ' varchar', $sql); # use varchar not binary + $sql = preg_replace('/(varchar\([0-9]+\)(?! N))/', '$1 NULL', $sql); # MSSQL complains if NULL is put into a varchar + #$sql = preg_replace('/ binary/i',' varchar',$sql); # MSSQL binary's can't be assigned with strings, so use varchar's instead + #$sql = preg_replace('/(binary\([0-9]+\) (NOT NULL )?default) [\'"].*?[\'"]/i','$1 0',$sql); # binary default cannot be string + $sql = preg_replace('/[a-z]*(blob|text)([ ,])/i', 'text$2', $sql); # no BLOB types in MSSQL + $sql = preg_replace('/\).+?;/',');', $sql); # remove all table options + $sql = preg_replace('/ (un)?signed/i', '', $sql); + $sql = preg_replace('/ENUM\(.+?\)/','TEXT',$sql); # Make ENUM's into TEXT's + $sql = str_replace(' bool ', ' bit ', $sql); + $sql = str_replace('auto_increment', 'IDENTITY(1,1)', $sql); + #$sql = preg_replace('/NOT NULL(?! IDENTITY)/', 'NULL', $sql); # Allow NULL's for non IDENTITY columns + + # Tidy up and write file + $sql = preg_replace('/,\s*\)/s', "\n)", $sql); # Remove spurious commas left after INDEX removals + $sql = preg_replace('/^\s*^/m', '', $sql); # Remove empty lines + $sql = preg_replace('/;$/m', ";\n", $sql); # Separate each statement with an empty line + file_put_contents($mssql_tmpl, $sql); + } + + # Parse the MSSQL template replacing inline variables such as /*$wgDBprefix*/ + $err = $this->sourceFile($mssql_tmpl); + if ($err !== true) $this->reportQueryError($err,0,$sql,__FUNCTION__); + + # Use DatabasePostgres's code to populate interwiki from MySQL template + $f = fopen($mysql_iw,'r'); + if ($f == false) dieout("<li>Could not find the interwiki.sql file"); + $sql = "INSERT INTO {$this->mTablePrefix}interwiki(iw_prefix,iw_url,iw_local) VALUES "; + while (!feof($f)) { + $line = fgets($f,1024); + $matches = array(); + if (!preg_match('/^\s*(\(.+?),(\d)\)/', $line, $matches)) continue; + $this->query("$sql $matches[1],$matches[2])"); + } + } + + /** + * No-op lock functions + */ + public function lock( $lockName, $method ) { + return true; + } + public function unlock( $lockName, $method ) { + return true; + } + +} + +/** + * @ingroup Database + */ +class MSSQLField extends MySQLField { + + function __construct() { + } + + static function fromText($db, $table, $field) { + $n = new MSSQLField; + $n->name = $field; + $n->tablename = $table; + return $n; + } + +} // end DatabaseMssql class + diff --git a/includes/db/DatabaseOracle.php b/includes/db/DatabaseOracle.php new file mode 100644 index 00000000..f4dbac71 --- /dev/null +++ b/includes/db/DatabaseOracle.php @@ -0,0 +1,720 @@ +<?php +/** + * @ingroup Database + * @file + */ + +/** + * This is the Oracle database abstraction layer. + * @ingroup Database + */ +class ORABlob { + var $mData; + + function __construct($data) { + $this->mData = $data; + } + + function getData() { + return $this->mData; + } +} + +/** + * The oci8 extension is fairly weak and doesn't support oci_num_rows, among + * other things. We use a wrapper class to handle that and other + * Oracle-specific bits, like converting column names back to lowercase. + * @ingroup Database + */ +class ORAResult { + private $rows; + private $cursor; + private $stmt; + private $nrows; + private $db; + + function __construct(&$db, $stmt) { + $this->db =& $db; + if (($this->nrows = oci_fetch_all($stmt, $this->rows, 0, -1, OCI_FETCHSTATEMENT_BY_ROW | OCI_NUM)) === false) { + $e = oci_error($stmt); + $db->reportQueryError($e['message'], $e['code'], '', __FUNCTION__); + return; + } + + $this->cursor = 0; + $this->stmt = $stmt; + } + + function free() { + oci_free_statement($this->stmt); + } + + function seek($row) { + $this->cursor = min($row, $this->nrows); + } + + function numRows() { + return $this->nrows; + } + + function numFields() { + return oci_num_fields($this->stmt); + } + + function fetchObject() { + if ($this->cursor >= $this->nrows) + return false; + + $row = $this->rows[$this->cursor++]; + $ret = new stdClass(); + foreach ($row as $k => $v) { + $lc = strtolower(oci_field_name($this->stmt, $k + 1)); + $ret->$lc = $v; + } + + return $ret; + } + + function fetchAssoc() { + if ($this->cursor >= $this->nrows) + return false; + + $row = $this->rows[$this->cursor++]; + $ret = array(); + foreach ($row as $k => $v) { + $lc = strtolower(oci_field_name($this->stmt, $k + 1)); + $ret[$lc] = $v; + $ret[$k] = $v; + } + return $ret; + } +} + +/** + * @ingroup Database + */ +class DatabaseOracle extends Database { + var $mInsertId = NULL; + var $mLastResult = NULL; + var $numeric_version = NULL; + var $lastResult = null; + var $cursor = 0; + var $mAffectedRows; + + function DatabaseOracle($server = false, $user = false, $password = false, $dbName = false, + $failFunction = false, $flags = 0 ) + { + + global $wgOut; + # Can't get a reference if it hasn't been set yet + if ( !isset( $wgOut ) ) { + $wgOut = NULL; + } + $this->mOut =& $wgOut; + $this->mFailFunction = $failFunction; + $this->mFlags = $flags; + $this->open( $server, $user, $password, $dbName); + + } + + function cascadingDeletes() { + return true; + } + function cleanupTriggers() { + return true; + } + function strictIPs() { + return true; + } + function realTimestamps() { + return true; + } + function implicitGroupby() { + return false; + } + function implicitOrderby() { + return false; + } + function searchableIPs() { + return true; + } + + static function newFromParams( $server = false, $user = false, $password = false, $dbName = false, + $failFunction = false, $flags = 0) + { + return new DatabaseOracle( $server, $user, $password, $dbName, $failFunction, $flags ); + } + + /** + * Usually aborts on failure + * If the failFunction is set to a non-zero integer, returns success + */ + function open( $server, $user, $password, $dbName ) { + if ( !function_exists( 'oci_connect' ) ) { + throw new DBConnectionError( $this, "Oracle functions missing, have you compiled PHP with the --with-oci8 option?\n (Note: if you recently installed PHP, you may need to restart your webserver and database)\n" ); + } + + # Needed for proper UTF-8 functionality + putenv("NLS_LANG=AMERICAN_AMERICA.AL32UTF8"); + + $this->close(); + $this->mServer = $server; + $this->mUser = $user; + $this->mPassword = $password; + $this->mDBname = $dbName; + + if (!strlen($user)) { ## e.g. the class is being loaded + return; + } + + error_reporting( E_ALL ); + $this->mConn = oci_connect($user, $password, $dbName); + + if ($this->mConn == false) { + wfDebug("DB connection error\n"); + wfDebug("Server: $server, Database: $dbName, User: $user, Password: " . substr( $password, 0, 3 ) . "...\n"); + wfDebug($this->lastError()."\n"); + return false; + } + + $this->mOpened = true; + return $this->mConn; + } + + /** + * Closes a database connection, if it is open + * Returns success, true if already closed + */ + function close() { + $this->mOpened = false; + if ( $this->mConn ) { + return oci_close( $this->mConn ); + } else { + return true; + } + } + + function execFlags() { + return $this->mTrxLevel ? OCI_DEFAULT : OCI_COMMIT_ON_SUCCESS; + } + + function doQuery($sql) { + wfDebug("SQL: [$sql]\n"); + if (!mb_check_encoding($sql)) { + throw new MWException("SQL encoding is invalid"); + } + + if (($this->mLastResult = $stmt = oci_parse($this->mConn, $sql)) === false) { + $e = oci_error($this->mConn); + $this->reportQueryError($e['message'], $e['code'], $sql, __FUNCTION__); + } + + if (oci_execute($stmt, $this->execFlags()) == false) { + $e = oci_error($stmt); + $this->reportQueryError($e['message'], $e['code'], $sql, __FUNCTION__); + } + if (oci_statement_type($stmt) == "SELECT") + return new ORAResult($this, $stmt); + else { + $this->mAffectedRows = oci_num_rows($stmt); + return true; + } + } + + function queryIgnore($sql, $fname = '') { + return $this->query($sql, $fname, true); + } + + function freeResult($res) { + $res->free(); + } + + function fetchObject($res) { + return $res->fetchObject(); + } + + function fetchRow($res) { + return $res->fetchAssoc(); + } + + function numRows($res) { + return $res->numRows(); + } + + function numFields($res) { + return $res->numFields(); + } + + function fieldName($stmt, $n) { + return pg_field_name($stmt, $n); + } + + /** + * This must be called after nextSequenceVal + */ + function insertId() { + return $this->mInsertId; + } + + function dataSeek($res, $row) { + $res->seek($row); + } + + function lastError() { + if ($this->mConn === false) + $e = oci_error(); + else + $e = oci_error($this->mConn); + return $e['message']; + } + + function lastErrno() { + if ($this->mConn === false) + $e = oci_error(); + else + $e = oci_error($this->mConn); + return $e['code']; + } + + function affectedRows() { + return $this->mAffectedRows; + } + + /** + * Returns information about an index + * If errors are explicitly ignored, returns NULL on failure + */ + function indexInfo( $table, $index, $fname = 'Database::indexExists' ) { + return false; + } + + function indexUnique ($table, $index, $fname = 'Database::indexUnique' ) { + return false; + } + + function insert( $table, $a, $fname = 'Database::insert', $options = array() ) { + if (!is_array($options)) + $options = array($options); + + #if (in_array('IGNORE', $options)) + # $oldIgnore = $this->ignoreErrors(true); + + # IGNORE is performed using single-row inserts, ignoring errors in each + # FIXME: need some way to distiguish between key collision and other types of error + //$oldIgnore = $this->ignoreErrors(true); + if (!is_array(reset($a))) { + $a = array($a); + } + foreach ($a as $row) { + $this->insertOneRow($table, $row, $fname); + } + //$this->ignoreErrors($oldIgnore); + $retVal = true; + + //if (in_array('IGNORE', $options)) + // $this->ignoreErrors($oldIgnore); + + return $retVal; + } + + function insertOneRow($table, $row, $fname) { + // "INSERT INTO tables (a, b, c)" + $sql = "INSERT INTO " . $this->tableName($table) . " (" . join(',', array_keys($row)) . ')'; + $sql .= " VALUES ("; + + // for each value, append ":key" + $first = true; + $returning = ''; + foreach ($row as $col => $val) { + if (is_object($val)) { + $what = "EMPTY_BLOB()"; + assert($returning === ''); + $returning = " RETURNING $col INTO :bval"; + $blobcol = $col; + } else + $what = ":$col"; + + if ($first) + $sql .= "$what"; + else + $sql.= ", $what"; + $first = false; + } + $sql .= ") $returning"; + + $stmt = oci_parse($this->mConn, $sql); + foreach ($row as $col => $val) { + if (!is_object($val)) { + if (oci_bind_by_name($stmt, ":$col", $row[$col]) === false) + $this->reportQueryError($this->lastErrno(), $this->lastError(), $sql, __METHOD__); + } + } + + if (($bval = oci_new_descriptor($this->mConn, OCI_D_LOB)) === false) { + $e = oci_error($stmt); + throw new DBUnexpectedError($this, "Cannot create LOB descriptor: " . $e['message']); + } + + if (strlen($returning)) + oci_bind_by_name($stmt, ":bval", $bval, -1, SQLT_BLOB); + + if (oci_execute($stmt, OCI_DEFAULT) === false) { + $e = oci_error($stmt); + $this->reportQueryError($e['message'], $e['code'], $sql, __METHOD__); + } + if (strlen($returning)) { + $bval->save($row[$blobcol]->getData()); + $bval->free(); + } + if (!$this->mTrxLevel) + oci_commit($this->mConn); + + oci_free_statement($stmt); + } + + function tableName( $name ) { + # Replace reserved words with better ones + switch( $name ) { + case 'user': + return 'mwuser'; + case 'text': + return 'pagecontent'; + default: + return $name; + } + } + + /** + * Return the next in a sequence, save the value for retrieval via insertId() + */ + function nextSequenceValue($seqName) { + $res = $this->query("SELECT $seqName.nextval FROM dual"); + $row = $this->fetchRow($res); + $this->mInsertId = $row[0]; + $this->freeResult($res); + return $this->mInsertId; + } + + /** + * Oracle does not have a "USE INDEX" clause, so return an empty string + */ + function useIndexClause($index) { + return ''; + } + + # REPLACE query wrapper + # Oracle simulates this with a DELETE followed by INSERT + # $row is the row to insert, an associative array + # $uniqueIndexes is an array of indexes. Each element may be either a + # field name or an array of field names + # + # It may be more efficient to leave off unique indexes which are unlikely to collide. + # However if you do this, you run the risk of encountering errors which wouldn't have + # occurred in MySQL + function replace( $table, $uniqueIndexes, $rows, $fname = 'Database::replace' ) { + $table = $this->tableName($table); + + if (count($rows)==0) { + return; + } + + # Single row case + if (!is_array(reset($rows))) { + $rows = array($rows); + } + + foreach( $rows as $row ) { + # Delete rows which collide + if ( $uniqueIndexes ) { + $sql = "DELETE FROM $table WHERE "; + $first = true; + foreach ( $uniqueIndexes as $index ) { + if ( $first ) { + $first = false; + $sql .= "("; + } else { + $sql .= ') OR ('; + } + if ( is_array( $index ) ) { + $first2 = true; + foreach ( $index as $col ) { + if ( $first2 ) { + $first2 = false; + } else { + $sql .= ' AND '; + } + $sql .= $col.'=' . $this->addQuotes( $row[$col] ); + } + } else { + $sql .= $index.'=' . $this->addQuotes( $row[$index] ); + } + } + $sql .= ')'; + $this->query( $sql, $fname ); + } + + # Now insert the row + $sql = "INSERT INTO $table (" . $this->makeList( array_keys( $row ), LIST_NAMES ) .') VALUES (' . + $this->makeList( $row, LIST_COMMA ) . ')'; + $this->query($sql, $fname); + } + } + + # DELETE where the condition is a join + function deleteJoin( $delTable, $joinTable, $delVar, $joinVar, $conds, $fname = "Database::deleteJoin" ) { + if ( !$conds ) { + throw new DBUnexpectedError($this, 'Database::deleteJoin() called with empty $conds' ); + } + + $delTable = $this->tableName( $delTable ); + $joinTable = $this->tableName( $joinTable ); + $sql = "DELETE FROM $delTable WHERE $delVar IN (SELECT $joinVar FROM $joinTable "; + if ( $conds != '*' ) { + $sql .= 'WHERE ' . $this->makeList( $conds, LIST_AND ); + } + $sql .= ')'; + + $this->query( $sql, $fname ); + } + + # Returns the size of a text field, or -1 for "unlimited" + function textFieldSize( $table, $field ) { + $table = $this->tableName( $table ); + $sql = "SELECT t.typname as ftype,a.atttypmod as size + FROM pg_class c, pg_attribute a, pg_type t + WHERE relname='$table' AND a.attrelid=c.oid AND + a.atttypid=t.oid and a.attname='$field'"; + $res =$this->query($sql); + $row=$this->fetchObject($res); + if ($row->ftype=="varchar") { + $size=$row->size-4; + } else { + $size=$row->size; + } + $this->freeResult( $res ); + return $size; + } + + function lowPriorityOption() { + return ''; + } + + function limitResult($sql, $limit, $offset) { + if ($offset === false) + $offset = 0; + return "SELECT * FROM ($sql) WHERE rownum >= (1 + $offset) AND rownum < 1 + $limit + $offset"; + } + + /** + * Returns an SQL expression for a simple conditional. + * Uses CASE on Oracle + * + * @param string $cond SQL expression which will result in a boolean value + * @param string $trueVal SQL expression to return if true + * @param string $falseVal SQL expression to return if false + * @return string SQL fragment + */ + function conditional( $cond, $trueVal, $falseVal ) { + return " (CASE WHEN $cond THEN $trueVal ELSE $falseVal END) "; + } + + function wasDeadlock() { + return $this->lastErrno() == 'OCI-00060'; + } + + function timestamp($ts = 0) { + return wfTimestamp(TS_ORACLE, $ts); + } + + /** + * Return aggregated value function call + */ + function aggregateValue ($valuedata,$valuename='value') { + return $valuedata; + } + + function reportQueryError($error, $errno, $sql, $fname, $tempIgnore = false) { + # Ignore errors during error handling to avoid infinite + # recursion + $ignore = $this->ignoreErrors(true); + ++$this->mErrorCount; + + if ($ignore || $tempIgnore) { +echo "error ignored! query = [$sql]\n"; + wfDebug("SQL ERROR (ignored): $error\n"); + $this->ignoreErrors( $ignore ); + } + else { +echo "error!\n"; + $message = "A database error has occurred\n" . + "Query: $sql\n" . + "Function: $fname\n" . + "Error: $errno $error\n"; + throw new DBUnexpectedError($this, $message); + } + } + + /** + * @return string wikitext of a link to the server software's web site + */ + function getSoftwareLink() { + return "[http://www.oracle.com/ Oracle]"; + } + + /** + * @return string Version information from the database + */ + function getServerVersion() { + return oci_server_version($this->mConn); + } + + /** + * Query whether a given table exists (in the given schema, or the default mw one if not given) + */ + function tableExists($table) { + $etable= $this->addQuotes($table); + $SQL = "SELECT 1 FROM user_tables WHERE table_name='$etable'"; + $res = $this->query($SQL); + $count = $res ? oci_num_rows($res) : 0; + if ($res) + $this->freeResult($res); + return $count; + } + + /** + * Query whether a given column exists in the mediawiki schema + */ + function fieldExists( $table, $field ) { + return true; // XXX + } + + function fieldInfo( $table, $field ) { + return false; // XXX + } + + function begin( $fname = '' ) { + $this->mTrxLevel = 1; + } + function immediateCommit( $fname = '' ) { + return true; + } + function commit( $fname = '' ) { + oci_commit($this->mConn); + $this->mTrxLevel = 0; + } + + /* Not even sure why this is used in the main codebase... */ + function limitResultForUpdate($sql, $num) { + return $sql; + } + + function strencode($s) { + return str_replace("'", "''", $s); + } + + function encodeBlob($b) { + return new ORABlob($b); + } + function decodeBlob($b) { + return $b; //return $b->load(); + } + + function addQuotes( $s ) { + global $wgLang; + $s = $wgLang->checkTitleEncoding($s); + return "'" . $this->strencode($s) . "'"; + } + + function quote_ident( $s ) { + return $s; + } + + /* For now, does nothing */ + function selectDB( $db ) { + return true; + } + + /** + * Returns an optional USE INDEX clause to go after the table, and a + * string to go at the end of the query + * + * @private + * + * @param array $options an associative array of options to be turned into + * an SQL query, valid keys are listed in the function. + * @return array + */ + function makeSelectOptions( $options ) { + $preLimitTail = $postLimitTail = ''; + $startOpts = ''; + + $noKeyOptions = array(); + foreach ( $options as $key => $option ) { + if ( is_numeric( $key ) ) { + $noKeyOptions[$option] = true; + } + } + + if ( isset( $options['GROUP BY'] ) ) $preLimitTail .= " GROUP BY {$options['GROUP BY']}"; + if ( isset( $options['ORDER BY'] ) ) $preLimitTail .= " ORDER BY {$options['ORDER BY']}"; + + if (isset($options['LIMIT'])) { + // $tailOpts .= $this->limitResult('', $options['LIMIT'], + // isset($options['OFFSET']) ? $options['OFFSET'] + // : false); + } + + #if ( isset( $noKeyOptions['FOR UPDATE'] ) ) $tailOpts .= ' FOR UPDATE'; + #if ( isset( $noKeyOptions['LOCK IN SHARE MODE'] ) ) $tailOpts .= ' LOCK IN SHARE MODE'; + if ( isset( $noKeyOptions['DISTINCT'] ) || isset( $noKeyOptions['DISTINCTROW'] ) ) $startOpts .= 'DISTINCT'; + + if ( isset( $options['USE INDEX'] ) && ! is_array( $options['USE INDEX'] ) ) { + $useIndex = $this->useIndexClause( $options['USE INDEX'] ); + } else { + $useIndex = ''; + } + + return array( $startOpts, $useIndex, $preLimitTail, $postLimitTail ); + } + + public function setTimeout( $timeout ) { + // @todo fixme no-op + } + + function ping() { + wfDebug( "Function ping() not written for DatabaseOracle.php yet"); + return true; + } + + /** + * How lagged is this slave? + * + * @return int + */ + public function getLag() { + # Not implemented for Oracle + return 0; + } + + function setFakeSlaveLag( $lag ) {} + function setFakeMaster( $enabled = true ) {} + + function getDBname() { + return $this->mDBname; + } + + function getServer() { + return $this->mServer; + } + + /** + * No-op lock functions + */ + public function lock( $lockName, $method ) { + return true; + } + public function unlock( $lockName, $method ) { + return true; + } + +} // end DatabaseOracle class diff --git a/includes/db/DatabasePostgres.php b/includes/db/DatabasePostgres.php new file mode 100644 index 00000000..065ad56d --- /dev/null +++ b/includes/db/DatabasePostgres.php @@ -0,0 +1,1394 @@ +<?php +/** + * @ingroup Database + * @file + * This is the Postgres database abstraction layer. + * + */ +class PostgresField { + private $name, $tablename, $type, $nullable, $max_length; + + static function fromText($db, $table, $field) { + global $wgDBmwschema; + + $q = <<<END +SELECT +CASE WHEN typname = 'int2' THEN 'smallint' +WHEN typname = 'int4' THEN 'integer' +WHEN typname = 'int8' THEN 'bigint' +WHEN typname = 'bpchar' THEN 'char' +ELSE typname END AS typname, +attnotnull, attlen +FROM pg_class, pg_namespace, pg_attribute, pg_type +WHERE relnamespace=pg_namespace.oid +AND relkind='r' +AND attrelid=pg_class.oid +AND atttypid=pg_type.oid +AND nspname=%s +AND relname=%s +AND attname=%s; +END; + $res = $db->query(sprintf($q, + $db->addQuotes($wgDBmwschema), + $db->addQuotes($table), + $db->addQuotes($field))); + $row = $db->fetchObject($res); + if (!$row) + return null; + $n = new PostgresField; + $n->type = $row->typname; + $n->nullable = ($row->attnotnull == 'f'); + $n->name = $field; + $n->tablename = $table; + $n->max_length = $row->attlen; + return $n; + } + + function name() { + return $this->name; + } + + function tableName() { + return $this->tablename; + } + + function type() { + return $this->type; + } + + function nullable() { + return $this->nullable; + } + + function maxLength() { + return $this->max_length; + } +} + +/** + * @ingroup Database + */ +class DatabasePostgres extends Database { + var $mInsertId = NULL; + var $mLastResult = NULL; + var $numeric_version = NULL; + + function DatabasePostgres($server = false, $user = false, $password = false, $dbName = false, + $failFunction = false, $flags = 0 ) + { + + global $wgOut; + # Can't get a reference if it hasn't been set yet + if ( !isset( $wgOut ) ) { + $wgOut = NULL; + } + $this->mOut =& $wgOut; + $this->mFailFunction = $failFunction; + $this->mFlags = $flags; + $this->open( $server, $user, $password, $dbName); + + } + + function cascadingDeletes() { + return true; + } + function cleanupTriggers() { + return true; + } + function strictIPs() { + return true; + } + function realTimestamps() { + return true; + } + function implicitGroupby() { + return false; + } + function implicitOrderby() { + return false; + } + function searchableIPs() { + return true; + } + function functionalIndexes() { + return true; + } + + function hasConstraint( $name ) { + global $wgDBmwschema; + $SQL = "SELECT 1 FROM pg_catalog.pg_constraint c, pg_catalog.pg_namespace n WHERE c.connamespace = n.oid AND conname = '" . pg_escape_string( $name ) . "' AND n.nspname = '" . pg_escape_string($wgDBmwschema) ."'"; + return $this->numRows($res = $this->doQuery($SQL)); + } + + static function newFromParams( $server, $user, $password, $dbName, $failFunction = false, $flags = 0) + { + return new DatabasePostgres( $server, $user, $password, $dbName, $failFunction, $flags ); + } + + /** + * Usually aborts on failure + * If the failFunction is set to a non-zero integer, returns success + */ + function open( $server, $user, $password, $dbName ) { + # Test for Postgres support, to avoid suppressed fatal error + if ( !function_exists( 'pg_connect' ) ) { + throw new DBConnectionError( $this, "Postgres functions missing, have you compiled PHP with the --with-pgsql option?\n (Note: if you recently installed PHP, you may need to restart your webserver and database)\n" ); + } + + global $wgDBport; + + if (!strlen($user)) { ## e.g. the class is being loaded + return; + } + + $this->close(); + $this->mServer = $server; + $this->mPort = $port = $wgDBport; + $this->mUser = $user; + $this->mPassword = $password; + $this->mDBname = $dbName; + + $hstring=""; + if ($server!=false && $server!="") { + $hstring="host=$server "; + } + if ($port!=false && $port!="") { + $hstring .= "port=$port "; + } + + error_reporting( E_ALL ); + @$this->mConn = pg_connect("$hstring dbname=$dbName user=$user password=$password"); + + if ( $this->mConn == false ) { + wfDebug( "DB connection error\n" ); + wfDebug( "Server: $server, Database: $dbName, User: $user, Password: " . substr( $password, 0, 3 ) . "...\n" ); + wfDebug( $this->lastError()."\n" ); + return false; + } + + $this->mOpened = true; + + global $wgCommandLineMode; + ## If called from the command-line (e.g. importDump), only show errors + if ($wgCommandLineMode) { + $this->doQuery("SET client_min_messages = 'ERROR'"); + } + + global $wgDBmwschema, $wgDBts2schema; + if (isset( $wgDBmwschema ) && isset( $wgDBts2schema ) + && $wgDBmwschema !== 'mediawiki' + && preg_match( '/^\w+$/', $wgDBmwschema ) + && preg_match( '/^\w+$/', $wgDBts2schema ) + ) { + $safeschema = $this->quote_ident($wgDBmwschema); + $safeschema2 = $this->quote_ident($wgDBts2schema); + $this->doQuery("SET search_path = $safeschema, $wgDBts2schema, public"); + } + + return $this->mConn; + } + + + function initial_setup($password, $dbName) { + // If this is the initial connection, setup the schema stuff and possibly create the user + global $wgDBname, $wgDBuser, $wgDBpassword, $wgDBsuperuser, $wgDBmwschema, $wgDBts2schema; + + print "<li>Checking the version of Postgres..."; + $version = $this->getServerVersion(); + $PGMINVER = '8.1'; + if ($this->numeric_version < $PGMINVER) { + print "<b>FAILED</b>. Required version is $PGMINVER. You have $this->numeric_version ($version)</li>\n"; + dieout("</ul>"); + } + print "version $this->numeric_version is OK.</li>\n"; + + $safeuser = $this->quote_ident($wgDBuser); + // Are we connecting as a superuser for the first time? + if ($wgDBsuperuser) { + // Are we really a superuser? Check out our rights + $SQL = "SELECT + CASE WHEN usesuper IS TRUE THEN + CASE WHEN usecreatedb IS TRUE THEN 3 ELSE 1 END + ELSE CASE WHEN usecreatedb IS TRUE THEN 2 ELSE 0 END + END AS rights + FROM pg_catalog.pg_user WHERE usename = " . $this->addQuotes($wgDBsuperuser); + $rows = $this->numRows($res = $this->doQuery($SQL)); + if (!$rows) { + print "<li>ERROR: Could not read permissions for user \"$wgDBsuperuser\"</li>\n"; + dieout('</ul>'); + } + $perms = pg_fetch_result($res, 0, 0); + + $SQL = "SELECT 1 FROM pg_catalog.pg_user WHERE usename = " . $this->addQuotes($wgDBuser); + $rows = $this->numRows($this->doQuery($SQL)); + if ($rows) { + print "<li>User \"$wgDBuser\" already exists, skipping account creation.</li>"; + } + else { + if ($perms != 1 and $perms != 3) { + print "<li>ERROR: the user \"$wgDBsuperuser\" cannot create other users. "; + print 'Please use a different Postgres user.</li>'; + dieout('</ul>'); + } + print "<li>Creating user <b>$wgDBuser</b>..."; + $safepass = $this->addQuotes($wgDBpassword); + $SQL = "CREATE USER $safeuser NOCREATEDB PASSWORD $safepass"; + $this->doQuery($SQL); + print "OK</li>\n"; + } + // User now exists, check out the database + if ($dbName != $wgDBname) { + $SQL = "SELECT 1 FROM pg_catalog.pg_database WHERE datname = " . $this->addQuotes($wgDBname); + $rows = $this->numRows($this->doQuery($SQL)); + if ($rows) { + print "<li>Database \"$wgDBname\" already exists, skipping database creation.</li>"; + } + else { + if ($perms < 2) { + print "<li>ERROR: the user \"$wgDBsuperuser\" cannot create databases. "; + print 'Please use a different Postgres user.</li>'; + dieout('</ul>'); + } + print "<li>Creating database <b>$wgDBname</b>..."; + $safename = $this->quote_ident($wgDBname); + $SQL = "CREATE DATABASE $safename OWNER $safeuser "; + $this->doQuery($SQL); + print "OK</li>\n"; + // Hopefully tsearch2 and plpgsql are in template1... + } + + // Reconnect to check out tsearch2 rights for this user + print "<li>Connecting to \"$wgDBname\" as superuser \"$wgDBsuperuser\" to check rights..."; + + $hstring=""; + if ($this->mServer!=false && $this->mServer!="") { + $hstring="host=$this->mServer "; + } + if ($this->mPort!=false && $this->mPort!="") { + $hstring .= "port=$this->mPort "; + } + + @$this->mConn = pg_connect("$hstring dbname=$wgDBname user=$wgDBsuperuser password=$password"); + if ( $this->mConn == false ) { + print "<b>FAILED TO CONNECT!</b></li>"; + dieout("</ul>"); + } + print "OK</li>\n"; + } + + if ($this->numeric_version < 8.3) { + // Tsearch2 checks + print "<li>Checking that tsearch2 is installed in the database \"$wgDBname\"..."; + if (! $this->tableExists("pg_ts_cfg", $wgDBts2schema)) { + print "<b>FAILED</b>. tsearch2 must be installed in the database \"$wgDBname\"."; + print "Please see <a href='http://www.devx.com/opensource/Article/21674/0/page/2'>this article</a>"; + print " for instructions or ask on #postgresql on irc.freenode.net</li>\n"; + dieout("</ul>"); + } + print "OK</li>\n"; + print "<li>Ensuring that user \"$wgDBuser\" has select rights on the tsearch2 tables..."; + foreach (array('cfg','cfgmap','dict','parser') as $table) { + $SQL = "GRANT SELECT ON pg_ts_$table TO $safeuser"; + $this->doQuery($SQL); + } + print "OK</li>\n"; + } + + // Setup the schema for this user if needed + $result = $this->schemaExists($wgDBmwschema); + $safeschema = $this->quote_ident($wgDBmwschema); + if (!$result) { + print "<li>Creating schema <b>$wgDBmwschema</b> ..."; + $result = $this->doQuery("CREATE SCHEMA $safeschema AUTHORIZATION $safeuser"); + if (!$result) { + print "<b>FAILED</b>.</li>\n"; + dieout("</ul>"); + } + print "OK</li>\n"; + } + else { + print "<li>Schema already exists, explicitly granting rights...\n"; + $safeschema2 = $this->addQuotes($wgDBmwschema); + $SQL = "SELECT 'GRANT ALL ON '||pg_catalog.quote_ident(relname)||' TO $safeuser;'\n". + "FROM pg_catalog.pg_class p, pg_catalog.pg_namespace n\n". + "WHERE relnamespace = n.oid AND n.nspname = $safeschema2\n". + "AND p.relkind IN ('r','S','v')\n"; + $SQL .= "UNION\n"; + $SQL .= "SELECT 'GRANT ALL ON FUNCTION '||pg_catalog.quote_ident(proname)||'('||\n". + "pg_catalog.oidvectortypes(p.proargtypes)||') TO $safeuser;'\n". + "FROM pg_catalog.pg_proc p, pg_catalog.pg_namespace n\n". + "WHERE p.pronamespace = n.oid AND n.nspname = $safeschema2"; + $res = $this->doQuery($SQL); + if (!$res) { + print "<b>FAILED</b>. Could not set rights for the user.</li>\n"; + dieout("</ul>"); + } + $this->doQuery("SET search_path = $safeschema"); + $rows = $this->numRows($res); + while ($rows) { + $rows--; + $this->doQuery(pg_fetch_result($res, $rows, 0)); + } + print "OK</li>"; + } + + // Install plpgsql if needed + $this->setup_plpgsql(); + + $wgDBsuperuser = ''; + return true; // Reconnect as regular user + + } // end superuser + + if (!defined('POSTGRES_SEARCHPATH')) { + + if ($this->numeric_version < 8.3) { + // Do we have the basic tsearch2 table? + print "<li>Checking for tsearch2 in the schema \"$wgDBts2schema\"..."; + if (! $this->tableExists("pg_ts_dict", $wgDBts2schema)) { + print "<b>FAILED</b>. Make sure tsearch2 is installed. See <a href="; + print "'http://www.devx.com/opensource/Article/21674/0/page/2'>this article</a>"; + print " for instructions.</li>\n"; + dieout("</ul>"); + } + print "OK</li>\n"; + + // Does this user have the rights to the tsearch2 tables? + $ctype = pg_fetch_result($this->doQuery("SHOW lc_ctype"),0,0); + print "<li>Checking tsearch2 permissions..."; + // Let's check all four, just to be safe + error_reporting( 0 ); + $ts2tables = array('cfg','cfgmap','dict','parser'); + $safetsschema = $this->quote_ident($wgDBts2schema); + foreach ( $ts2tables AS $tname ) { + $SQL = "SELECT count(*) FROM $safetsschema.pg_ts_$tname"; + $res = $this->doQuery($SQL); + if (!$res) { + print "<b>FAILED</b> to access pg_ts_$tname. Make sure that the user ". + "\"$wgDBuser\" has SELECT access to all four tsearch2 tables</li>\n"; + dieout("</ul>"); + } + } + $SQL = "SELECT ts_name FROM $safetsschema.pg_ts_cfg WHERE locale = '$ctype'"; + $SQL .= " ORDER BY CASE WHEN ts_name <> 'default' THEN 1 ELSE 0 END"; + $res = $this->doQuery($SQL); + error_reporting( E_ALL ); + if (!$res) { + print "<b>FAILED</b>. Could not determine the tsearch2 locale information</li>\n"; + dieout("</ul>"); + } + print "OK</li>"; + + // Will the current locale work? Can we force it to? + print "<li>Verifying tsearch2 locale with $ctype..."; + $rows = $this->numRows($res); + $resetlocale = 0; + if (!$rows) { + print "<b>not found</b></li>\n"; + print "<li>Attempting to set default tsearch2 locale to \"$ctype\"..."; + $resetlocale = 1; + } + else { + $tsname = pg_fetch_result($res, 0, 0); + if ($tsname != 'default') { + print "<b>not set to default ($tsname)</b>"; + print "<li>Attempting to change tsearch2 default locale to \"$ctype\"..."; + $resetlocale = 1; + } + } + if ($resetlocale) { + $SQL = "UPDATE $safetsschema.pg_ts_cfg SET locale = '$ctype' WHERE ts_name = 'default'"; + $res = $this->doQuery($SQL); + if (!$res) { + print "<b>FAILED</b>. "; + print "Please make sure that the locale in pg_ts_cfg for \"default\" is set to \"$ctype\"</li>\n"; + dieout("</ul>"); + } + print "OK</li>"; + } + + // Final test: try out a simple tsearch2 query + $SQL = "SELECT $safetsschema.to_tsvector('default','MediaWiki tsearch2 testing')"; + $res = $this->doQuery($SQL); + if (!$res) { + print "<b>FAILED</b>. Specifically, \"$SQL\" did not work.</li>"; + dieout("</ul>"); + } + print "OK</li>"; + } + + // Install plpgsql if needed + $this->setup_plpgsql(); + + // Does the schema already exist? Who owns it? + $result = $this->schemaExists($wgDBmwschema); + if (!$result) { + print "<li>Creating schema <b>$wgDBmwschema</b> ..."; + error_reporting( 0 ); + $safeschema = $this->quote_ident($wgDBmwschema); + $result = $this->doQuery("CREATE SCHEMA $safeschema"); + error_reporting( E_ALL ); + if (!$result) { + print "<b>FAILED</b>. The user \"$wgDBuser\" must be able to access the schema. ". + "You can try making them the owner of the database, or try creating the schema with a ". + "different user, and then grant access to the \"$wgDBuser\" user.</li>\n"; + dieout("</ul>"); + } + print "OK</li>\n"; + } + else if ($result != $wgDBuser) { + print "<li>Schema \"$wgDBmwschema\" exists but is not owned by \"$wgDBuser\". Not ideal.</li>\n"; + } + else { + print "<li>Schema \"$wgDBmwschema\" exists and is owned by \"$wgDBuser\". Excellent.</li>\n"; + } + + // Always return GMT time to accomodate the existing integer-based timestamp assumption + print "<li>Setting the timezone to GMT for user \"$wgDBuser\" ..."; + $SQL = "ALTER USER $safeuser SET timezone = 'GMT'"; + $result = pg_query($this->mConn, $SQL); + if (!$result) { + print "<b>FAILED</b>.</li>\n"; + dieout("</ul>"); + } + print "OK</li>\n"; + // Set for the rest of this session + $SQL = "SET timezone = 'GMT'"; + $result = pg_query($this->mConn, $SQL); + if (!$result) { + print "<li>Failed to set timezone</li>\n"; + dieout("</ul>"); + } + + print "<li>Setting the datestyle to ISO, YMD for user \"$wgDBuser\" ..."; + $SQL = "ALTER USER $safeuser SET datestyle = 'ISO, YMD'"; + $result = pg_query($this->mConn, $SQL); + if (!$result) { + print "<b>FAILED</b>.</li>\n"; + dieout("</ul>"); + } + print "OK</li>\n"; + // Set for the rest of this session + $SQL = "SET datestyle = 'ISO, YMD'"; + $result = pg_query($this->mConn, $SQL); + if (!$result) { + print "<li>Failed to set datestyle</li>\n"; + dieout("</ul>"); + } + + // Fix up the search paths if needed + print "<li>Setting the search path for user \"$wgDBuser\" ..."; + $path = $this->quote_ident($wgDBmwschema); + if ($wgDBts2schema !== $wgDBmwschema) + $path .= ", ". $this->quote_ident($wgDBts2schema); + if ($wgDBmwschema !== 'public' and $wgDBts2schema !== 'public') + $path .= ", public"; + $SQL = "ALTER USER $safeuser SET search_path = $path"; + $result = pg_query($this->mConn, $SQL); + if (!$result) { + print "<b>FAILED</b>.</li>\n"; + dieout("</ul>"); + } + print "OK</li>\n"; + // Set for the rest of this session + $SQL = "SET search_path = $path"; + $result = pg_query($this->mConn, $SQL); + if (!$result) { + print "<li>Failed to set search_path</li>\n"; + dieout("</ul>"); + } + define( "POSTGRES_SEARCHPATH", $path ); + } + } + + + function setup_plpgsql() { + print "<li>Checking for Pl/Pgsql ..."; + $SQL = "SELECT 1 FROM pg_catalog.pg_language WHERE lanname = 'plpgsql'"; + $rows = $this->numRows($this->doQuery($SQL)); + if ($rows < 1) { + // plpgsql is not installed, but if we have a pg_pltemplate table, we should be able to create it + print "not installed. Attempting to install Pl/Pgsql ..."; + $SQL = "SELECT 1 FROM pg_catalog.pg_class c JOIN pg_catalog.pg_namespace n ON (n.oid = c.relnamespace) ". + "WHERE relname = 'pg_pltemplate' AND nspname='pg_catalog'"; + $rows = $this->numRows($this->doQuery($SQL)); + if ($rows >= 1) { + $olde = error_reporting(0); + error_reporting($olde - E_WARNING); + $result = $this->doQuery("CREATE LANGUAGE plpgsql"); + error_reporting($olde); + if (!$result) { + print "<b>FAILED</b>. You need to install the language plpgsql in the database <tt>$wgDBname</tt></li>"; + dieout("</ul>"); + } + } + else { + print "<b>FAILED</b>. You need to install the language plpgsql in the database <tt>$wgDBname</tt></li>"; + dieout("</ul>"); + } + } + print "OK</li>\n"; + } + + + /** + * Closes a database connection, if it is open + * Returns success, true if already closed + */ + function close() { + $this->mOpened = false; + if ( $this->mConn ) { + return pg_close( $this->mConn ); + } else { + return true; + } + } + + function doQuery( $sql ) { + if (function_exists('mb_convert_encoding')) { + return $this->mLastResult=pg_query( $this->mConn , mb_convert_encoding($sql,'UTF-8') ); + } + return $this->mLastResult=pg_query( $this->mConn , $sql); + } + + function queryIgnore( $sql, $fname = '' ) { + return $this->query( $sql, $fname, true ); + } + + function freeResult( $res ) { + if ( $res instanceof ResultWrapper ) { + $res = $res->result; + } + if ( !@pg_free_result( $res ) ) { + throw new DBUnexpectedError($this, "Unable to free Postgres result\n" ); + } + } + + function fetchObject( $res ) { + if ( $res instanceof ResultWrapper ) { + $res = $res->result; + } + @$row = pg_fetch_object( $res ); + # FIXME: HACK HACK HACK HACK debug + + # TODO: + # hashar : not sure if the following test really trigger if the object + # fetching failed. + if( pg_last_error($this->mConn) ) { + throw new DBUnexpectedError($this, 'SQL error: ' . htmlspecialchars( pg_last_error($this->mConn) ) ); + } + return $row; + } + + function fetchRow( $res ) { + if ( $res instanceof ResultWrapper ) { + $res = $res->result; + } + @$row = pg_fetch_array( $res ); + if( pg_last_error($this->mConn) ) { + throw new DBUnexpectedError($this, 'SQL error: ' . htmlspecialchars( pg_last_error($this->mConn) ) ); + } + return $row; + } + + function numRows( $res ) { + if ( $res instanceof ResultWrapper ) { + $res = $res->result; + } + @$n = pg_num_rows( $res ); + if( pg_last_error($this->mConn) ) { + throw new DBUnexpectedError($this, 'SQL error: ' . htmlspecialchars( pg_last_error($this->mConn) ) ); + } + return $n; + } + function numFields( $res ) { + if ( $res instanceof ResultWrapper ) { + $res = $res->result; + } + return pg_num_fields( $res ); + } + function fieldName( $res, $n ) { + if ( $res instanceof ResultWrapper ) { + $res = $res->result; + } + return pg_field_name( $res, $n ); + } + + /** + * This must be called after nextSequenceVal + */ + function insertId() { + return $this->mInsertId; + } + + function dataSeek( $res, $row ) { + if ( $res instanceof ResultWrapper ) { + $res = $res->result; + } + return pg_result_seek( $res, $row ); + } + + function lastError() { + if ( $this->mConn ) { + return pg_last_error(); + } + else { + return "No database connection"; + } + } + function lastErrno() { + return pg_last_error() ? 1 : 0; + } + + function affectedRows() { + if( !isset( $this->mLastResult ) or ! $this->mLastResult ) + return 0; + + return pg_affected_rows( $this->mLastResult ); + } + + /** + * Estimate rows in dataset + * Returns estimated count, based on EXPLAIN output + * This is not necessarily an accurate estimate, so use sparingly + * Returns -1 if count cannot be found + * Takes same arguments as Database::select() + */ + + function estimateRowCount( $table, $vars='*', $conds='', $fname = 'Database::estimateRowCount', $options = array() ) { + $options['EXPLAIN'] = true; + $res = $this->select( $table, $vars, $conds, $fname, $options ); + $rows = -1; + if ( $res ) { + $row = $this->fetchRow( $res ); + $count = array(); + if( preg_match( '/rows=(\d+)/', $row[0], $count ) ) { + $rows = $count[1]; + } + $this->freeResult($res); + } + return $rows; + } + + + /** + * Returns information about an index + * If errors are explicitly ignored, returns NULL on failure + */ + function indexInfo( $table, $index, $fname = 'Database::indexExists' ) { + $sql = "SELECT indexname FROM pg_indexes WHERE tablename='$table'"; + $res = $this->query( $sql, $fname ); + if ( !$res ) { + return NULL; + } + while ( $row = $this->fetchObject( $res ) ) { + if ( $row->indexname == $index ) { + return $row; + } + } + return false; + } + + function indexUnique ($table, $index, $fname = 'Database::indexUnique' ) { + $sql = "SELECT indexname FROM pg_indexes WHERE tablename='{$table}'". + " AND indexdef LIKE 'CREATE UNIQUE%({$index})'"; + $res = $this->query( $sql, $fname ); + if ( !$res ) + return NULL; + while ($row = $this->fetchObject( $res )) + return true; + return false; + + } + + /** + * INSERT wrapper, inserts an array into a table + * + * $args may be a single associative array, or an array of these with numeric keys, + * for multi-row insert (Postgres version 8.2 and above only). + * + * @param array $table String: Name of the table to insert to. + * @param array $args Array: Items to insert into the table. + * @param array $fname String: Name of the function, for profiling + * @param mixed $options String or Array. Valid options: IGNORE + * + * @return bool Success of insert operation. IGNORE always returns true. + */ + function insert( $table, $args, $fname = 'DatabasePostgres::insert', $options = array() ) { + global $wgDBversion; + + if ( !count( $args ) ) { + return true; + } + + $table = $this->tableName( $table ); + if (! isset( $wgDBversion ) ) { + $this->getServerVersion(); + $wgDBversion = $this->numeric_version; + } + + if ( !is_array( $options ) ) + $options = array( $options ); + + if ( isset( $args[0] ) && is_array( $args[0] ) ) { + $multi = true; + $keys = array_keys( $args[0] ); + } + else { + $multi = false; + $keys = array_keys( $args ); + } + + // If IGNORE is set, we use savepoints to emulate mysql's behavior + $ignore = in_array( 'IGNORE', $options ) ? 'mw' : ''; + + // If we are not in a transaction, we need to be for savepoint trickery + $didbegin = 0; + if ( $ignore ) { + if (! $this->mTrxLevel) { + $this->begin(); + $didbegin = 1; + } + $olde = error_reporting( 0 ); + // For future use, we may want to track the number of actual inserts + // Right now, insert (all writes) simply return true/false + $numrowsinserted = 0; + } + + $sql = "INSERT INTO $table (" . implode( ',', $keys ) . ') VALUES '; + + if ( $multi ) { + if ( $wgDBversion >= 8.2 && !$ignore ) { + $first = true; + foreach ( $args as $row ) { + if ( $first ) { + $first = false; + } else { + $sql .= ','; + } + $sql .= '(' . $this->makeList( $row ) . ')'; + } + $res = (bool)$this->query( $sql, $fname, $ignore ); + } + else { + $res = true; + $origsql = $sql; + foreach ( $args as $row ) { + $tempsql = $origsql; + $tempsql .= '(' . $this->makeList( $row ) . ')'; + + if ( $ignore ) { + pg_query($this->mConn, "SAVEPOINT $ignore"); + } + + $tempres = (bool)$this->query( $tempsql, $fname, $ignore ); + + if ( $ignore ) { + $bar = pg_last_error(); + if ($bar != false) { + pg_query( $this->mConn, "ROLLBACK TO $ignore" ); + } + else { + pg_query( $this->mConn, "RELEASE $ignore" ); + $numrowsinserted++; + } + } + + // If any of them fail, we fail overall for this function call + // Note that this will be ignored if IGNORE is set + if (! $tempres) + $res = false; + } + } + } + else { + // Not multi, just a lone insert + if ( $ignore ) { + pg_query($this->mConn, "SAVEPOINT $ignore"); + } + + $sql .= '(' . $this->makeList( $args ) . ')'; + $res = (bool)$this->query( $sql, $fname, $ignore ); + + if ( $ignore ) { + $bar = pg_last_error(); + if ($bar != false) { + pg_query( $this->mConn, "ROLLBACK TO $ignore" ); + } + else { + pg_query( $this->mConn, "RELEASE $ignore" ); + $numrowsinserted++; + } + } + } + + if ( $ignore ) { + $olde = error_reporting( $olde ); + if ($didbegin) { + $this->commit(); + } + + // IGNORE always returns true + return true; + } + + + return $res; + + } + + function tableName( $name ) { + # Replace reserved words with better ones + switch( $name ) { + case 'user': + return 'mwuser'; + case 'text': + return 'pagecontent'; + default: + return $name; + } + } + + /** + * Return the next in a sequence, save the value for retrieval via insertId() + */ + function nextSequenceValue( $seqName ) { + $safeseq = preg_replace( "/'/", "''", $seqName ); + $res = $this->query( "SELECT nextval('$safeseq')" ); + $row = $this->fetchRow( $res ); + $this->mInsertId = $row[0]; + $this->freeResult( $res ); + return $this->mInsertId; + } + + /** + * Return the current value of a sequence. Assumes it has ben nextval'ed in this session. + */ + function currentSequenceValue( $seqName ) { + $safeseq = preg_replace( "/'/", "''", $seqName ); + $res = $this->query( "SELECT currval('$safeseq')" ); + $row = $this->fetchRow( $res ); + $currval = $row[0]; + $this->freeResult( $res ); + return $currval; + } + + /** + * Postgres does not have a "USE INDEX" clause, so return an empty string + */ + function useIndexClause( $index ) { + return ''; + } + + # REPLACE query wrapper + # Postgres simulates this with a DELETE followed by INSERT + # $row is the row to insert, an associative array + # $uniqueIndexes is an array of indexes. Each element may be either a + # field name or an array of field names + # + # It may be more efficient to leave off unique indexes which are unlikely to collide. + # However if you do this, you run the risk of encountering errors which wouldn't have + # occurred in MySQL + function replace( $table, $uniqueIndexes, $rows, $fname = 'Database::replace' ) { + $table = $this->tableName( $table ); + + if (count($rows)==0) { + return; + } + + # Single row case + if ( !is_array( reset( $rows ) ) ) { + $rows = array( $rows ); + } + + foreach( $rows as $row ) { + # Delete rows which collide + if ( $uniqueIndexes ) { + $sql = "DELETE FROM $table WHERE "; + $first = true; + foreach ( $uniqueIndexes as $index ) { + if ( $first ) { + $first = false; + $sql .= "("; + } else { + $sql .= ') OR ('; + } + if ( is_array( $index ) ) { + $first2 = true; + foreach ( $index as $col ) { + if ( $first2 ) { + $first2 = false; + } else { + $sql .= ' AND '; + } + $sql .= $col.'=' . $this->addQuotes( $row[$col] ); + } + } else { + $sql .= $index.'=' . $this->addQuotes( $row[$index] ); + } + } + $sql .= ')'; + $this->query( $sql, $fname ); + } + + # Now insert the row + $sql = "INSERT INTO $table (" . $this->makeList( array_keys( $row ), LIST_NAMES ) .') VALUES (' . + $this->makeList( $row, LIST_COMMA ) . ')'; + $this->query( $sql, $fname ); + } + } + + # DELETE where the condition is a join + function deleteJoin( $delTable, $joinTable, $delVar, $joinVar, $conds, $fname = "Database::deleteJoin" ) { + if ( !$conds ) { + throw new DBUnexpectedError($this, 'Database::deleteJoin() called with empty $conds' ); + } + + $delTable = $this->tableName( $delTable ); + $joinTable = $this->tableName( $joinTable ); + $sql = "DELETE FROM $delTable WHERE $delVar IN (SELECT $joinVar FROM $joinTable "; + if ( $conds != '*' ) { + $sql .= 'WHERE ' . $this->makeList( $conds, LIST_AND ); + } + $sql .= ')'; + + $this->query( $sql, $fname ); + } + + # Returns the size of a text field, or -1 for "unlimited" + function textFieldSize( $table, $field ) { + $table = $this->tableName( $table ); + $sql = "SELECT t.typname as ftype,a.atttypmod as size + FROM pg_class c, pg_attribute a, pg_type t + WHERE relname='$table' AND a.attrelid=c.oid AND + a.atttypid=t.oid and a.attname='$field'"; + $res =$this->query($sql); + $row=$this->fetchObject($res); + if ($row->ftype=="varchar") { + $size=$row->size-4; + } else { + $size=$row->size; + } + $this->freeResult( $res ); + return $size; + } + + function lowPriorityOption() { + return ''; + } + + function limitResult($sql, $limit, $offset=false) { + return "$sql LIMIT $limit ".(is_numeric($offset)?" OFFSET {$offset} ":""); + } + + /** + * Returns an SQL expression for a simple conditional. + * Uses CASE on Postgres + * + * @param string $cond SQL expression which will result in a boolean value + * @param string $trueVal SQL expression to return if true + * @param string $falseVal SQL expression to return if false + * @return string SQL fragment + */ + function conditional( $cond, $trueVal, $falseVal ) { + return " (CASE WHEN $cond THEN $trueVal ELSE $falseVal END) "; + } + + function wasDeadlock() { + return $this->lastErrno() == '40P01'; + } + + function timestamp( $ts=0 ) { + return wfTimestamp(TS_POSTGRES,$ts); + } + + /** + * Return aggregated value function call + */ + function aggregateValue ($valuedata,$valuename='value') { + return $valuedata; + } + + + function reportQueryError( $error, $errno, $sql, $fname, $tempIgnore = false ) { + // Ignore errors during error handling to avoid infinite recursion + $ignore = $this->ignoreErrors( true ); + $this->mErrorCount++; + + if ($ignore || $tempIgnore) { + wfDebug("SQL ERROR (ignored): $error\n"); + $this->ignoreErrors( $ignore ); + } + else { + $message = "A database error has occurred\n" . + "Query: $sql\n" . + "Function: $fname\n" . + "Error: $errno $error\n"; + throw new DBUnexpectedError($this, $message); + } + } + + /** + * @return string wikitext of a link to the server software's web site + */ + function getSoftwareLink() { + return "[http://www.postgresql.org/ PostgreSQL]"; + } + + /** + * @return string Version information from the database + */ + function getServerVersion() { + $version = pg_fetch_result($this->doQuery("SELECT version()"),0,0); + $thisver = array(); + if (!preg_match('/PostgreSQL (\d+\.\d+)(\S+)/', $version, $thisver)) { + die("Could not determine the numeric version from $version!"); + } + $this->numeric_version = $thisver[1]; + return $version; + } + + + /** + * Query whether a given relation exists (in the given schema, or the + * default mw one if not given) + */ + function relationExists( $table, $types, $schema = false ) { + global $wgDBmwschema; + if (!is_array($types)) + $types = array($types); + if (! $schema ) + $schema = $wgDBmwschema; + $etable = $this->addQuotes($table); + $eschema = $this->addQuotes($schema); + $SQL = "SELECT 1 FROM pg_catalog.pg_class c, pg_catalog.pg_namespace n " + . "WHERE c.relnamespace = n.oid AND c.relname = $etable AND n.nspname = $eschema " + . "AND c.relkind IN ('" . implode("','", $types) . "')"; + $res = $this->query( $SQL ); + $count = $res ? $res->numRows() : 0; + if ($res) + $this->freeResult( $res ); + return $count ? true : false; + } + + /* + * For backward compatibility, this function checks both tables and + * views. + */ + function tableExists ($table, $schema = false) { + return $this->relationExists($table, array('r', 'v'), $schema); + } + + function sequenceExists ($sequence, $schema = false) { + return $this->relationExists($sequence, 'S', $schema); + } + + function triggerExists($table, $trigger) { + global $wgDBmwschema; + + $q = <<<END + SELECT 1 FROM pg_class, pg_namespace, pg_trigger + WHERE relnamespace=pg_namespace.oid AND relkind='r' + AND tgrelid=pg_class.oid + AND nspname=%s AND relname=%s AND tgname=%s +END; + $res = $this->query(sprintf($q, + $this->addQuotes($wgDBmwschema), + $this->addQuotes($table), + $this->addQuotes($trigger))); + if (!$res) + return NULL; + $rows = $res->numRows(); + $this->freeResult($res); + return $rows; + } + + function ruleExists($table, $rule) { + global $wgDBmwschema; + $exists = $this->selectField("pg_rules", "rulename", + array( "rulename" => $rule, + "tablename" => $table, + "schemaname" => $wgDBmwschema)); + return $exists === $rule; + } + + function constraintExists($table, $constraint) { + global $wgDBmwschema; + $SQL = sprintf("SELECT 1 FROM information_schema.table_constraints ". + "WHERE constraint_schema = %s AND table_name = %s AND constraint_name = %s", + $this->addQuotes($wgDBmwschema), + $this->addQuotes($table), + $this->addQuotes($constraint)); + $res = $this->query($SQL); + if (!$res) + return NULL; + $rows = $res->numRows(); + $this->freeResult($res); + return $rows; + } + + /** + * Query whether a given schema exists. Returns the name of the owner + */ + function schemaExists( $schema ) { + $eschema = preg_replace("/'/", "''", $schema); + $SQL = "SELECT rolname FROM pg_catalog.pg_namespace n, pg_catalog.pg_roles r " + ."WHERE n.nspowner=r.oid AND n.nspname = '$eschema'"; + $res = $this->query( $SQL ); + if ( $res && $res->numRows() ) { + $row = $res->fetchObject(); + $owner = $row->rolname; + } else { + $owner = false; + } + if ($res) + $this->freeResult($res); + return $owner; + } + + /** + * Query whether a given column exists in the mediawiki schema + */ + function fieldExists( $table, $field, $fname = 'DatabasePostgres::fieldExists' ) { + global $wgDBmwschema; + $etable = preg_replace("/'/", "''", $table); + $eschema = preg_replace("/'/", "''", $wgDBmwschema); + $ecol = preg_replace("/'/", "''", $field); + $SQL = "SELECT 1 FROM pg_catalog.pg_class c, pg_catalog.pg_namespace n, pg_catalog.pg_attribute a " + . "WHERE c.relnamespace = n.oid AND c.relname = '$etable' AND n.nspname = '$eschema' " + . "AND a.attrelid = c.oid AND a.attname = '$ecol'"; + $res = $this->query( $SQL, $fname ); + $count = $res ? $res->numRows() : 0; + if ($res) + $this->freeResult( $res ); + return $count; + } + + function fieldInfo( $table, $field ) { + return PostgresField::fromText($this, $table, $field); + } + + /** + * pg_field_type() wrapper + */ + function fieldType( $res, $index ) { + if ( $res instanceof ResultWrapper ) { + $res = $res->result; + } + return pg_field_type( $res, $index ); + } + + function begin( $fname = 'DatabasePostgres::begin' ) { + $this->query( 'BEGIN', $fname ); + $this->mTrxLevel = 1; + } + function immediateCommit( $fname = 'DatabasePostgres::immediateCommit' ) { + return true; + } + function commit( $fname = 'DatabasePostgres::commit' ) { + $this->query( 'COMMIT', $fname ); + $this->mTrxLevel = 0; + } + + /* Not even sure why this is used in the main codebase... */ + function limitResultForUpdate($sql, $num) { + return $sql; + } + + function setup_database() { + global $wgVersion, $wgDBmwschema, $wgDBts2schema, $wgDBport, $wgDBuser; + + // Make sure that we can write to the correct schema + // If not, Postgres will happily and silently go to the next search_path item + $ctest = "mediawiki_test_table"; + $safeschema = $this->quote_ident($wgDBmwschema); + if ($this->tableExists($ctest, $wgDBmwschema)) { + $this->doQuery("DROP TABLE $safeschema.$ctest"); + } + $SQL = "CREATE TABLE $safeschema.$ctest(a int)"; + $olde = error_reporting( 0 ); + $res = $this->doQuery($SQL); + error_reporting( $olde ); + if (!$res) { + print "<b>FAILED</b>. Make sure that the user \"$wgDBuser\" can write to the schema \"$wgDBmwschema\"</li>\n"; + dieout("</ul>"); + } + $this->doQuery("DROP TABLE $safeschema.$ctest"); + + $res = dbsource( "../maintenance/postgres/tables.sql", $this); + + ## Update version information + $mwv = $this->addQuotes($wgVersion); + $pgv = $this->addQuotes($this->getServerVersion()); + $pgu = $this->addQuotes($this->mUser); + $mws = $this->addQuotes($wgDBmwschema); + $tss = $this->addQuotes($wgDBts2schema); + $pgp = $this->addQuotes($wgDBport); + $dbn = $this->addQuotes($this->mDBname); + $ctype = pg_fetch_result($this->doQuery("SHOW lc_ctype"),0,0); + + $SQL = "UPDATE mediawiki_version SET mw_version=$mwv, pg_version=$pgv, pg_user=$pgu, ". + "mw_schema = $mws, ts2_schema = $tss, pg_port=$pgp, pg_dbname=$dbn, ". + "ctype = '$ctype' ". + "WHERE type = 'Creation'"; + $this->query($SQL); + + ## Avoid the non-standard "REPLACE INTO" syntax + $f = fopen( "../maintenance/interwiki.sql", 'r' ); + if ($f == false ) { + dieout( "<li>Could not find the interwiki.sql file"); + } + ## We simply assume it is already empty as we have just created it + $SQL = "INSERT INTO interwiki(iw_prefix,iw_url,iw_local) VALUES "; + while ( ! feof( $f ) ) { + $line = fgets($f,1024); + $matches = array(); + if (!preg_match('/^\s*(\(.+?),(\d)\)/', $line, $matches)) { + continue; + } + $this->query("$SQL $matches[1],$matches[2])"); + } + print " (table interwiki successfully populated)...\n"; + + $this->doQuery("COMMIT"); + } + + function encodeBlob( $b ) { + return new Blob ( pg_escape_bytea( $b ) ) ; + } + + function decodeBlob( $b ) { + if ($b instanceof Blob) { + $b = $b->fetch(); + } + return pg_unescape_bytea( $b ); + } + + function strencode( $s ) { ## Should not be called by us + return pg_escape_string( $s ); + } + + function addQuotes( $s ) { + if ( is_null( $s ) ) { + return 'NULL'; + } else if ($s instanceof Blob) { + return "'".$s->fetch($s)."'"; + } + return "'" . pg_escape_string($s) . "'"; + } + + function quote_ident( $s ) { + return '"' . preg_replace( '/"/', '""', $s) . '"'; + } + + /* For now, does nothing */ + function selectDB( $db ) { + return true; + } + + /** + * Postgres specific version of replaceVars. + * Calls the parent version in Database.php + * + * @private + * + * @param string $com SQL string, read from a stream (usually tables.sql) + * + * @return string SQL string + */ + protected function replaceVars( $ins ) { + + $ins = parent::replaceVars( $ins ); + + if ($this->numeric_version >= 8.3) { + // Thanks for not providing backwards-compatibility, 8.3 + $ins = preg_replace( "/to_tsvector\s*\(\s*'default'\s*,/", 'to_tsvector(', $ins ); + } + + if ($this->numeric_version <= 8.1) { // Our minimum version + $ins = str_replace( 'USING gin', 'USING gist', $ins ); + } + + return $ins; + } + + /** + * Various select options + * + * @private + * + * @param array $options an associative array of options to be turned into + * an SQL query, valid keys are listed in the function. + * @return array + */ + function makeSelectOptions( $options ) { + $preLimitTail = $postLimitTail = ''; + $startOpts = $useIndex = ''; + + $noKeyOptions = array(); + foreach ( $options as $key => $option ) { + if ( is_numeric( $key ) ) { + $noKeyOptions[$option] = true; + } + } + + if ( isset( $options['GROUP BY'] ) ) $preLimitTail .= " GROUP BY " . $options['GROUP BY']; + if ( isset( $options['HAVING'] ) ) $preLimitTail .= " HAVING {$options['HAVING']}"; + if ( isset( $options['ORDER BY'] ) ) $preLimitTail .= " ORDER BY " . $options['ORDER BY']; + + //if (isset($options['LIMIT'])) { + // $tailOpts .= $this->limitResult('', $options['LIMIT'], + // isset($options['OFFSET']) ? $options['OFFSET'] + // : false); + //} + + if ( isset( $noKeyOptions['FOR UPDATE'] ) ) $postLimitTail .= ' FOR UPDATE'; + if ( isset( $noKeyOptions['LOCK IN SHARE MODE'] ) ) $postLimitTail .= ' LOCK IN SHARE MODE'; + if ( isset( $noKeyOptions['DISTINCT'] ) || isset( $noKeyOptions['DISTINCTROW'] ) ) $startOpts .= 'DISTINCT'; + + return array( $startOpts, $useIndex, $preLimitTail, $postLimitTail ); + } + + public function setTimeout( $timeout ) { + // @todo fixme no-op + } + + function ping() { + wfDebug( "Function ping() not written for DatabasePostgres.php yet"); + return true; + } + + /** + * How lagged is this slave? + * + */ + public function getLag() { + # Not implemented for PostgreSQL + return false; + } + + function setFakeSlaveLag( $lag ) {} + function setFakeMaster( $enabled = true ) {} + + function getDBname() { + return $this->mDBname; + } + + function getServer() { + return $this->mServer; + } + + function buildConcat( $stringList ) { + return implode( ' || ', $stringList ); + } + + /* These are not used yet, but we know we don't want the default version */ + + public function lock( $lockName, $method ) { + return true; + } + public function unlock( $lockName, $method ) { + return true; + } + +} // end DatabasePostgres class diff --git a/includes/db/DatabaseSqlite.php b/includes/db/DatabaseSqlite.php new file mode 100644 index 00000000..5299c688 --- /dev/null +++ b/includes/db/DatabaseSqlite.php @@ -0,0 +1,405 @@ +<?php +/** + * This script is the SQLite database abstraction layer + * + * See maintenance/sqlite/README for development notes and other specific information + * @ingroup Database + * @file + */ + +/** + * @ingroup Database + */ +class DatabaseSqlite extends Database { + + var $mAffectedRows; + var $mLastResult; + var $mDatabaseFile; + + /** + * Constructor + */ + function __construct($server = false, $user = false, $password = false, $dbName = false, $failFunction = false, $flags = 0) { + global $wgOut,$wgSQLiteDataDir; + if ("$wgSQLiteDataDir" == '') $wgSQLiteDataDir = dirname($_SERVER['DOCUMENT_ROOT']).'/data'; + if (!is_dir($wgSQLiteDataDir)) mkdir($wgSQLiteDataDir,0700); + if (!isset($wgOut)) $wgOut = NULL; # Can't get a reference if it hasn't been set yet + $this->mOut =& $wgOut; + $this->mFailFunction = $failFunction; + $this->mFlags = $flags; + $this->mDatabaseFile = "$wgSQLiteDataDir/$dbName.sqlite"; + $this->open($server, $user, $password, $dbName); + } + + /** + * todo: check if these should be true like parent class + */ + function implicitGroupby() { return false; } + function implicitOrderby() { return false; } + + static function newFromParams($server, $user, $password, $dbName, $failFunction = false, $flags = 0) { + return new DatabaseSqlite($server, $user, $password, $dbName, $failFunction, $flags); + } + + /** Open an SQLite database and return a resource handle to it + * NOTE: only $dbName is used, the other parameters are irrelevant for SQLite databases + */ + function open($server,$user,$pass,$dbName) { + $this->mConn = false; + if ($dbName) { + $file = $this->mDatabaseFile; + if ($this->mFlags & DBO_PERSISTENT) $this->mConn = new PDO("sqlite:$file",$user,$pass,array(PDO::ATTR_PERSISTENT => true)); + else $this->mConn = new PDO("sqlite:$file",$user,$pass); + if ($this->mConn === false) wfDebug("DB connection error: $err\n");; + $this->mOpened = $this->mConn; + $this->mConn->setAttribute(PDO::ATTR_ERRMODE,PDO::ERRMODE_SILENT); # set error codes only, dont raise exceptions + } + return $this->mConn; + } + + /** + * Close an SQLite database + */ + function close() { + $this->mOpened = false; + if (is_object($this->mConn)) { + if ($this->trxLevel()) $this->immediateCommit(); + $this->mConn = null; + } + return true; + } + + /** + * SQLite doesn't allow buffered results or data seeking etc, so we'll use fetchAll as the result + */ + function doQuery($sql) { + $res = $this->mConn->query($sql); + if ($res === false) $this->reportQueryError($this->lastError(),$this->lastErrno(),$sql,__FUNCTION__); + else { + $r = $res instanceof ResultWrapper ? $res->result : $res; + $this->mAffectedRows = $r->rowCount(); + $res = new ResultWrapper($this,$r->fetchAll()); + } + return $res; + } + + function freeResult(&$res) { + if ($res instanceof ResultWrapper) $res->result = NULL; else $res = NULL; + } + + function fetchObject(&$res) { + if ($res instanceof ResultWrapper) $r =& $res->result; else $r =& $res; + $cur = current($r); + if (is_array($cur)) { + next($r); + $obj = new stdClass; + foreach ($cur as $k => $v) if (!is_numeric($k)) $obj->$k = $v; + return $obj; + } + return false; + } + + function fetchRow(&$res) { + if ($res instanceof ResultWrapper) $r =& $res->result; else $r =& $res; + $cur = current($r); + if (is_array($cur)) { + next($r); + return $cur; + } + return false; + } + + /** + * The PDO::Statement class implements the array interface so count() will work + */ + function numRows(&$res) { + $r = $res instanceof ResultWrapper ? $res->result : $res; + return count($r); + } + + function numFields(&$res) { + $r = $res instanceof ResultWrapper ? $res->result : $res; + return is_array($r) ? count($r[0]) : 0; + } + + function fieldName(&$res,$n) { + $r = $res instanceof ResultWrapper ? $res->result : $res; + if (is_array($r)) { + $keys = array_keys($r[0]); + return $keys[$n]; + } + return false; + } + + /** + * Use MySQL's naming (accounts for prefix etc) but remove surrounding backticks + */ + function tableName($name) { + return str_replace('`','',parent::tableName($name)); + } + + /** + * This must be called after nextSequenceVal + */ + function insertId() { + return $this->mConn->lastInsertId(); + } + + function dataSeek(&$res,$row) { + if ($res instanceof ResultWrapper) $r =& $res->result; else $r =& $res; + reset($r); + if ($row > 0) for ($i = 0; $i < $row; $i++) next($r); + } + + function lastError() { + if (!is_object($this->mConn)) return "Cannot return last error, no db connection"; + $e = $this->mConn->errorInfo(); + return isset($e[2]) ? $e[2] : ''; + } + + function lastErrno() { + if (!is_object($this->mConn)) return "Cannot return last error, no db connection"; + return $this->mConn->errorCode(); + } + + function affectedRows() { + return $this->mAffectedRows; + } + + /** + * Returns information about an index + * - if errors are explicitly ignored, returns NULL on failure + */ + function indexInfo($table, $index, $fname = 'Database::indexExists') { + return false; + } + + function indexUnique($table, $index, $fname = 'Database::indexUnique') { + return false; + } + + /** + * Filter the options used in SELECT statements + */ + function makeSelectOptions($options) { + foreach ($options as $k => $v) if (is_numeric($k) && $v == 'FOR UPDATE') $options[$k] = ''; + return parent::makeSelectOptions($options); + } + + /** + * Based on MySQL method (parent) with some prior SQLite-sepcific adjustments + */ + function insert($table, $a, $fname = 'DatabaseSqlite::insert', $options = array()) { + if (!count($a)) return true; + if (!is_array($options)) $options = array($options); + + # SQLite uses OR IGNORE not just IGNORE + foreach ($options as $k => $v) if ($v == 'IGNORE') $options[$k] = 'OR IGNORE'; + + # SQLite can't handle multi-row inserts, so divide up into multiple single-row inserts + if (isset($a[0]) && is_array($a[0])) { + $ret = true; + foreach ($a as $k => $v) if (!parent::insert($table,$v,"$fname/multi-row",$options)) $ret = false; + } + else $ret = parent::insert($table,$a,"$fname/single-row",$options); + + return $ret; + } + + /** + * SQLite does not have a "USE INDEX" clause, so return an empty string + */ + function useIndexClause($index) { + return ''; + } + + # Returns the size of a text field, or -1 for "unlimited" + function textFieldSize($table, $field) { + return -1; + } + + /** + * No low priority option in SQLite + */ + function lowPriorityOption() { + return ''; + } + + /** + * Returns an SQL expression for a simple conditional. + * - uses CASE on SQLite + */ + function conditional($cond, $trueVal, $falseVal) { + return " (CASE WHEN $cond THEN $trueVal ELSE $falseVal END) "; + } + + function wasDeadlock() { + return $this->lastErrno() == SQLITE_BUSY; + } + + /** + * @return string wikitext of a link to the server software's web site + */ + function getSoftwareLink() { + return "[http://sqlite.org/ SQLite]"; + } + + /** + * @return string Version information from the database + */ + function getServerVersion() { + global $wgContLang; + $ver = $this->mConn->getAttribute(PDO::ATTR_SERVER_VERSION); + $size = $wgContLang->formatSize(filesize($this->mDatabaseFile)); + $file = basename($this->mDatabaseFile); + return $ver." ($file: $size)"; + } + + /** + * Query whether a given column exists in the mediawiki schema + */ + function fieldExists($table, $field) { return true; } + + function fieldInfo($table, $field) { return SQLiteField::fromText($this, $table, $field); } + + function begin() { + if ($this->mTrxLevel == 1) $this->commit(); + $this->mConn->beginTransaction(); + $this->mTrxLevel = 1; + } + + function commit() { + if ($this->mTrxLevel == 0) return; + $this->mConn->commit(); + $this->mTrxLevel = 0; + } + + function rollback() { + if ($this->mTrxLevel == 0) return; + $this->mConn->rollBack(); + $this->mTrxLevel = 0; + } + + function limitResultForUpdate($sql, $num) { + return $sql; + } + + function strencode($s) { + return substr($this->addQuotes($s),1,-1); + } + + function encodeBlob($b) { + return $this->strencode($b); + } + + function decodeBlob($b) { + return $b; + } + + function addQuotes($s) { + return $this->mConn->quote($s); + } + + function quote_ident($s) { return $s; } + + /** + * For now, does nothing + */ + function selectDB($db) { return true; } + + /** + * not done + */ + public function setTimeout($timeout) { return; } + + function ping() { + wfDebug("Function ping() not written for SQLite yet"); + return true; + } + + /** + * How lagged is this slave? + */ + public function getLag() { + return 0; + } + + /** + * Called by the installer script (when modified according to the MediaWikiLite installation instructions) + * - this is the same way PostgreSQL works, MySQL reads in tables.sql and interwiki.sql using dbsource (which calls db->sourceFile) + */ + public function setup_database() { + global $IP,$wgSQLiteDataDir,$wgDBTableOptions; + $wgDBTableOptions = ''; + $mysql_tmpl = "$IP/maintenance/tables.sql"; + $mysql_iw = "$IP/maintenance/interwiki.sql"; + $sqlite_tmpl = "$IP/maintenance/sqlite/tables.sql"; + + # Make an SQLite template file if it doesn't exist (based on the same one MySQL uses to create a new wiki db) + if (!file_exists($sqlite_tmpl)) { + $sql = file_get_contents($mysql_tmpl); + $sql = preg_replace('/^\s*--.*?$/m','',$sql); # strip comments + $sql = preg_replace('/^\s*(UNIQUE)?\s*(PRIMARY)?\s*KEY.+?$/m','',$sql); + $sql = preg_replace('/^\s*(UNIQUE )?INDEX.+?$/m','',$sql); # These indexes should be created with a CREATE INDEX query + $sql = preg_replace('/^\s*FULLTEXT.+?$/m','',$sql); # Full text indexes + $sql = preg_replace('/ENUM\(.+?\)/','TEXT',$sql); # Make ENUM's into TEXT's + $sql = preg_replace('/binary\(\d+\)/','BLOB',$sql); + $sql = preg_replace('/(TYPE|MAX_ROWS|AVG_ROW_LENGTH)=\w+/','',$sql); + $sql = preg_replace('/,\s*\)/s',')',$sql); # removing previous items may leave a trailing comma + $sql = str_replace('binary','',$sql); + $sql = str_replace('auto_increment','PRIMARY KEY AUTOINCREMENT',$sql); + $sql = str_replace(' unsigned','',$sql); + $sql = str_replace(' int ',' INTEGER ',$sql); + $sql = str_replace('NOT NULL','',$sql); + + # Tidy up and write file + $sql = preg_replace('/^\s*^/m','',$sql); # Remove empty lines + $sql = preg_replace('/;$/m',";\n",$sql); # Separate each statement with an empty line + file_put_contents($sqlite_tmpl,$sql); + } + + # Parse the SQLite template replacing inline variables such as /*$wgDBprefix*/ + $err = $this->sourceFile($sqlite_tmpl); + if ($err !== true) $this->reportQueryError($err,0,$sql,__FUNCTION__); + + # Use DatabasePostgres's code to populate interwiki from MySQL template + $f = fopen($mysql_iw,'r'); + if ($f == false) dieout("<li>Could not find the interwiki.sql file"); + $sql = "INSERT INTO interwiki(iw_prefix,iw_url,iw_local) VALUES "; + while (!feof($f)) { + $line = fgets($f,1024); + $matches = array(); + if (!preg_match('/^\s*(\(.+?),(\d)\)/', $line, $matches)) continue; + $this->query("$sql $matches[1],$matches[2])"); + } + } + + /** + * No-op lock functions + */ + public function lock( $lockName, $method ) { + return true; + } + public function unlock( $lockName, $method ) { + return true; + } + +} + +/** + * @ingroup Database + */ +class SQLiteField extends MySQLField { + + function __construct() { + } + + static function fromText($db, $table, $field) { + $n = new SQLiteField; + $n->name = $field; + $n->tablename = $table; + return $n; + } + +} // end DatabaseSqlite class + diff --git a/includes/db/LBFactory.php b/includes/db/LBFactory.php new file mode 100644 index 00000000..256875d7 --- /dev/null +++ b/includes/db/LBFactory.php @@ -0,0 +1,261 @@ +<?php +/** + * @file + * @ingroup Database + */ + +/** + * An interface for generating database load balancers + * @ingroup Database + */ +abstract class LBFactory { + static $instance; + + /** + * Get an LBFactory instance + */ + static function &singleton() { + if ( is_null( self::$instance ) ) { + global $wgLBFactoryConf; + $class = $wgLBFactoryConf['class']; + self::$instance = new $class( $wgLBFactoryConf ); + } + return self::$instance; + } + + /** + * Shut down, close connections and destroy the cached instance. + * + */ + static function destroyInstance() { + if ( self::$instance ) { + self::$instance->shutdown(); + self::$instance->forEachLBCallMethod( 'closeAll' ); + self::$instance = null; + } + } + + /** + * Construct a factory based on a configuration array (typically from $wgLBFactoryConf) + */ + abstract function __construct( $conf ); + + /** + * Create a new load balancer object. The resulting object will be untracked, + * not chronology-protected, and the caller is responsible for cleaning it up. + * + * @param string $wiki Wiki ID, or false for the current wiki + * @return LoadBalancer + */ + abstract function newMainLB( $wiki = false ); + + /** + * Get a cached (tracked) load balancer object. + * + * @param string $wiki Wiki ID, or false for the current wiki + * @return LoadBalancer + */ + abstract function getMainLB( $wiki = false ); + + /* + * Create a new load balancer for external storage. The resulting object will be + * untracked, not chronology-protected, and the caller is responsible for + * cleaning it up. + * + * @param string $cluster External storage cluster, or false for core + * @param string $wiki Wiki ID, or false for the current wiki + */ + abstract function newExternalLB( $cluster, $wiki = false ); + + /* + * Get a cached (tracked) load balancer for external storage + * + * @param string $cluster External storage cluster, or false for core + * @param string $wiki Wiki ID, or false for the current wiki + */ + abstract function &getExternalLB( $cluster, $wiki = false ); + + /** + * Execute a function for each tracked load balancer + * The callback is called with the load balancer as the first parameter, + * and $params passed as the subsequent parameters. + */ + abstract function forEachLB( $callback, $params = array() ); + + /** + * Prepare all tracked load balancers for shutdown + * STUB + */ + function shutdown() {} + + /** + * Call a method of each tracked load balancer + */ + function forEachLBCallMethod( $methodName, $args = array() ) { + $this->forEachLB( array( $this, 'callMethod' ), array( $methodName, $args ) ); + } + + /** + * Private helper for forEachLBCallMethod + */ + function callMethod( $loadBalancer, $methodName, $args ) { + call_user_func_array( array( $loadBalancer, $methodName ), $args ); + } + + /** + * Commit changes on all master connections + */ + function commitMasterChanges() { + $this->forEachLBCallMethod( 'commitMasterChanges' ); + } +} + +/** + * A simple single-master LBFactory that gets its configuration from the b/c globals + */ +class LBFactory_Simple extends LBFactory { + var $mainLB; + var $extLBs = array(); + + # Chronology protector + var $chronProt; + + function __construct( $conf ) { + $this->chronProt = new ChronologyProtector; + } + + function newMainLB( $wiki = false ) { + global $wgDBservers, $wgMasterWaitTimeout; + if ( $wgDBservers ) { + $servers = $wgDBservers; + } else { + global $wgDBserver, $wgDBuser, $wgDBpassword, $wgDBname, $wgDBtype, $wgDebugDumpSql; + $servers = array(array( + 'host' => $wgDBserver, + 'user' => $wgDBuser, + 'password' => $wgDBpassword, + 'dbname' => $wgDBname, + 'type' => $wgDBtype, + 'load' => 1, + 'flags' => ($wgDebugDumpSql ? DBO_DEBUG : 0) | DBO_DEFAULT + )); + } + + return new LoadBalancer( array( + 'servers' => $servers, + 'masterWaitTimeout' => $wgMasterWaitTimeout + )); + } + + function getMainLB( $wiki = false ) { + if ( !isset( $this->mainLB ) ) { + $this->mainLB = $this->newMainLB( $wiki ); + $this->mainLB->parentInfo( array( 'id' => 'main' ) ); + $this->chronProt->initLB( $this->mainLB ); + } + return $this->mainLB; + } + + function newExternalLB( $cluster, $wiki = false ) { + global $wgExternalServers; + if ( !isset( $wgExternalServers[$cluster] ) ) { + throw new MWException( __METHOD__.": Unknown cluster \"$cluster\"" ); + } + return new LoadBalancer( array( + 'servers' => $wgExternalServers[$cluster] + )); + } + + function &getExternalLB( $cluster, $wiki = false ) { + if ( !isset( $this->extLBs[$cluster] ) ) { + $this->extLBs[$cluster] = $this->newExternalLB( $cluster, $wiki ); + $this->extLBs[$cluster]->parentInfo( array( 'id' => "ext-$cluster" ) ); + } + return $this->extLBs[$cluster]; + } + + /** + * Execute a function for each tracked load balancer + * The callback is called with the load balancer as the first parameter, + * and $params passed as the subsequent parameters. + */ + function forEachLB( $callback, $params = array() ) { + if ( isset( $this->mainLB ) ) { + call_user_func_array( $callback, array_merge( array( $this->mainLB ), $params ) ); + } + foreach ( $this->extLBs as $lb ) { + call_user_func_array( $callback, array_merge( array( $lb ), $params ) ); + } + } + + function shutdown() { + if ( $this->mainLB ) { + $this->chronProt->shutdownLB( $this->mainLB ); + } + $this->chronProt->shutdown(); + $this->commitMasterChanges(); + } +} + +/** + * Class for ensuring a consistent ordering of events as seen by the user, despite replication. + * Kind of like Hawking's [[Chronology Protection Agency]]. + */ +class ChronologyProtector { + var $startupPos; + var $shutdownPos = array(); + + /** + * Initialise a LoadBalancer to give it appropriate chronology protection. + * + * @param LoadBalancer $lb + */ + function initLB( $lb ) { + if ( $this->startupPos === null ) { + if ( !empty( $_SESSION[__CLASS__] ) ) { + $this->startupPos = $_SESSION[__CLASS__]; + } + } + if ( !$this->startupPos ) { + return; + } + $masterName = $lb->getServerName( 0 ); + + if ( $lb->getServerCount() > 1 && !empty( $this->startupPos[$masterName] ) ) { + $info = $lb->parentInfo(); + $pos = $this->startupPos[$masterName]; + wfDebug( __METHOD__.": LB " . $info['id'] . " waiting for master pos $pos\n" ); + $lb->waitFor( $this->startupPos[$masterName] ); + } + } + + /** + * Notify the ChronologyProtector that the LoadBalancer is about to shut + * down. Saves replication positions. + * + * @param LoadBalancer $lb + */ + function shutdownLB( $lb ) { + if ( session_id() != '' && $lb->getServerCount() > 1 ) { + $masterName = $lb->getServerName( 0 ); + if ( !isset( $this->shutdownPos[$masterName] ) ) { + $pos = $lb->getMasterPos(); + $info = $lb->parentInfo(); + wfDebug( __METHOD__.": LB " . $info['id'] . " has master pos $pos\n" ); + $this->shutdownPos[$masterName] = $pos; + } + } + } + + /** + * Notify the ChronologyProtector that the LBFactory is done calling shutdownLB() for now. + * May commit chronology data to persistent storage. + */ + function shutdown() { + if ( session_id() != '' && count( $this->shutdownPos ) ) { + wfDebug( __METHOD__.": saving master pos for " . + count( $this->shutdownPos ) . " master(s)\n" ); + $_SESSION[__CLASS__] = $this->shutdownPos; + } + } +} diff --git a/includes/db/LBFactory_Multi.php b/includes/db/LBFactory_Multi.php new file mode 100644 index 00000000..48c2d99b --- /dev/null +++ b/includes/db/LBFactory_Multi.php @@ -0,0 +1,233 @@ +<?php +/** + * @file + * @ingroup Database + */ + + +/** + * A multi-wiki, multi-master factory for Wikimedia and similar installations. + * Ignores the old configuration globals + * + * Configuration: + * sectionsByDB A map of database names to section names + * + * sectionLoads A 2-d map. For each section, gives a map of server names to load ratios. + * For example: array( 'section1' => array( 'db1' => 100, 'db2' => 100 ) ) + * + * serverTemplate A server info associative array as documented for $wgDBservers. The host, + * hostName and load entries will be overridden. + * + * groupLoadsBySection A 3-d map giving server load ratios for each section and group. For example: + * array( 'section1' => array( 'group1' => array( 'db1' => 100, 'db2' => 100 ) ) ) + * + * groupLoadsByDB A 3-d map giving server load ratios by DB name. + * + * hostsByName A map of hostname to IP address. + * + * externalLoads A map of external storage cluster name to server load map + * + * externalTemplateOverrides A set of server info keys overriding serverTemplate for external storage + * + * templateOverridesByServer A 2-d map overriding serverTemplate and externalTemplateOverrides on a + * server-by-server basis. Applies to both core and external storage. + * + * templateOverridesByCluster A 2-d map overriding the server info by external storage cluster + * + * masterTemplateOverrides An override array for all master servers. + * + * @ingroup Database + */ +class LBFactory_Multi extends LBFactory { + // Required settings + var $sectionsByDB, $sectionLoads, $serverTemplate; + // Optional settings + var $groupLoadsBySection = array(), $groupLoadsByDB = array(), $hostsByName = array(); + var $externalLoads = array(), $externalTemplateOverrides, $templateOverridesByServer; + var $templateOverridesByCluster, $masterTemplateOverrides; + // Other stuff + var $conf, $mainLBs = array(), $extLBs = array(); + var $lastWiki, $lastSection; + + function __construct( $conf ) { + $this->chronProt = new ChronologyProtector; + $this->conf = $conf; + $required = array( 'sectionsByDB', 'sectionLoads', 'serverTemplate' ); + $optional = array( 'groupLoadsBySection', 'groupLoadsByDB', 'hostsByName', + 'externalLoads', 'externalTemplateOverrides', 'templateOverridesByServer', + 'templateOverridesByCluster', 'masterTemplateOverrides' ); + + foreach ( $required as $key ) { + if ( !isset( $conf[$key] ) ) { + throw new MWException( __CLASS__.": $key is required in configuration" ); + } + $this->$key = $conf[$key]; + } + + foreach ( $optional as $key ) { + if ( isset( $conf[$key] ) ) { + $this->$key = $conf[$key]; + } + } + } + + function getSectionForWiki( $wiki = false ) { + if ( $this->lastWiki === $wiki ) { + return $this->lastSection; + } + list( $dbName, $prefix ) = $this->getDBNameAndPrefix( $wiki ); + if ( isset( $this->sectionsByDB[$dbName] ) ) { + $section = $this->sectionsByDB[$dbName]; + } else { + $section = 'DEFAULT'; + } + $this->lastSection = $section; + $this->lastWiki = $wiki; + return $section; + } + + function newMainLB( $wiki = false ) { + list( $dbName, $prefix ) = $this->getDBNameAndPrefix( $wiki ); + $section = $this->getSectionForWiki( $wiki ); + $groupLoads = array(); + if ( isset( $this->groupLoadsByDB[$dbName] ) ) { + $groupLoads = $this->groupLoadsByDB[$dbName]; + } + if ( isset( $this->groupLoadsBySection[$section] ) ) { + $groupLoads = array_merge_recursive( $groupLoads, $this->groupLoadsBySection[$section] ); + } + return $this->newLoadBalancer( $this->serverTemplate, $this->sectionLoads[$section], $groupLoads ); + } + + function getMainLB( $wiki = false ) { + $section = $this->getSectionForWiki( $wiki ); + if ( !isset( $this->mainLBs[$section] ) ) { + $lb = $this->newMainLB( $wiki, $section ); + $this->chronProt->initLB( $lb ); + $lb->parentInfo( array( 'id' => "main-$section" ) ); + $this->mainLBs[$section] = $lb; + } + return $this->mainLBs[$section]; + } + + function newExternalLB( $cluster, $wiki = false ) { + if ( !isset( $this->externalLoads[$cluster] ) ) { + throw new MWException( __METHOD__.": Unknown cluster \"$cluster\"" ); + } + $template = $this->serverTemplate; + if ( isset( $this->externalTemplateOverrides ) ) { + $template = $this->externalTemplateOverrides + $template; + } + if ( isset( $this->templateOverridesByCluster[$cluster] ) ) { + $template = $this->templateOverridesByCluster[$cluster] + $template; + } + return $this->newLoadBalancer( $template, $this->externalLoads[$cluster], array() ); + } + + function &getExternalLB( $cluster, $wiki = false ) { + if ( !isset( $this->extLBs[$cluster] ) ) { + $this->extLBs[$cluster] = $this->newExternalLB( $cluster, $wiki ); + $this->extLBs[$cluster]->parentInfo( array( 'id' => "ext-$cluster" ) ); + } + return $this->extLBs[$cluster]; + } + + /** + * Make a new load balancer object based on template and load array + */ + function newLoadBalancer( $template, $loads, $groupLoads ) { + global $wgMasterWaitTimeout; + $servers = $this->makeServerArray( $template, $loads, $groupLoads ); + $lb = new LoadBalancer( array( + 'servers' => $servers, + 'masterWaitTimeout' => $wgMasterWaitTimeout + )); + return $lb; + } + + /** + * Make a server array as expected by LoadBalancer::__construct, using a template and load array + */ + function makeServerArray( $template, $loads, $groupLoads ) { + $servers = array(); + $master = true; + $groupLoadsByServer = $this->reindexGroupLoads( $groupLoads ); + foreach ( $groupLoadsByServer as $server => $stuff ) { + if ( !isset( $loads[$server] ) ) { + $loads[$server] = 0; + } + } + foreach ( $loads as $serverName => $load ) { + $serverInfo = $template; + if ( $master ) { + $serverInfo['master'] = true; + if ( isset( $this->masterTemplateOverrides ) ) { + $serverInfo = $this->masterTemplateOverrides + $serverInfo; + } + $master = false; + } + if ( isset( $this->templateOverridesByServer[$serverName] ) ) { + $serverInfo = $this->templateOverridesByServer[$serverName] + $serverInfo; + } + if ( isset( $groupLoadsByServer[$serverName] ) ) { + $serverInfo['groupLoads'] = $groupLoadsByServer[$serverName]; + } + if ( isset( $this->hostsByName[$serverName] ) ) { + $serverInfo['host'] = $this->hostsByName[$serverName]; + } else { + $serverInfo['host'] = $serverName; + } + $serverInfo['hostName'] = $serverName; + $serverInfo['load'] = $load; + $servers[] = $serverInfo; + } + return $servers; + } + + /** + * Take a group load array indexed by group then server, and reindex it by server then group + */ + function reindexGroupLoads( $groupLoads ) { + $reindexed = array(); + foreach ( $groupLoads as $group => $loads ) { + foreach ( $loads as $server => $load ) { + $reindexed[$server][$group] = $load; + } + } + return $reindexed; + } + + /** + * Get the database name and prefix based on the wiki ID + */ + function getDBNameAndPrefix( $wiki = false ) { + if ( $wiki === false ) { + global $wgDBname, $wgDBprefix; + return array( $wgDBname, $wgDBprefix ); + } else { + return wfSplitWikiID( $wiki ); + } + } + + /** + * Execute a function for each tracked load balancer + * The callback is called with the load balancer as the first parameter, + * and $params passed as the subsequent parameters. + */ + function forEachLB( $callback, $params = array() ) { + foreach ( $this->mainLBs as $lb ) { + call_user_func_array( $callback, array_merge( array( $lb ), $params ) ); + } + foreach ( $this->extLBs as $lb ) { + call_user_func_array( $callback, array_merge( array( $lb ), $params ) ); + } + } + + function shutdown() { + foreach ( $this->mainLBs as $lb ) { + $this->chronProt->shutdownLB( $lb ); + } + $this->chronProt->shutdown(); + $this->commitMasterChanges(); + } +} diff --git a/includes/db/LoadBalancer.php b/includes/db/LoadBalancer.php new file mode 100644 index 00000000..42c4044d --- /dev/null +++ b/includes/db/LoadBalancer.php @@ -0,0 +1,918 @@ +<?php +/** + * @file + * @ingroup Database + */ + +/** + * Database load balancing object + * + * @todo document + * @ingroup Database + */ +class LoadBalancer { + /* private */ var $mServers, $mConns, $mLoads, $mGroupLoads; + /* private */ var $mFailFunction, $mErrorConnection; + /* private */ var $mReadIndex, $mLastIndex, $mAllowLagged; + /* private */ var $mWaitForPos, $mWaitTimeout; + /* private */ var $mLaggedSlaveMode, $mLastError = 'Unknown error'; + /* private */ var $mParentInfo, $mLagTimes; + /* private */ var $mLoadMonitorClass, $mLoadMonitor; + + /** + * @param array $params Array with keys: + * servers Required. Array of server info structures. + * failFunction Deprecated, use exceptions instead. + * masterWaitTimeout Replication lag wait timeout + * loadMonitor Name of a class used to fetch server lag and load. + */ + function __construct( $params ) + { + if ( !isset( $params['servers'] ) ) { + throw new MWException( __CLASS__.': missing servers parameter' ); + } + $this->mServers = $params['servers']; + + if ( isset( $params['failFunction'] ) ) { + $this->mFailFunction = $params['failFunction']; + } else { + $this->mFailFunction = false; + } + if ( isset( $params['waitTimeout'] ) ) { + $this->mWaitTimeout = $params['waitTimeout']; + } else { + $this->mWaitTimeout = 10; + } + + $this->mReadIndex = -1; + $this->mWriteIndex = -1; + $this->mConns = array( + 'local' => array(), + 'foreignUsed' => array(), + 'foreignFree' => array() ); + $this->mLastIndex = -1; + $this->mLoads = array(); + $this->mWaitForPos = false; + $this->mLaggedSlaveMode = false; + $this->mErrorConnection = false; + $this->mAllowLag = false; + $this->mLoadMonitorClass = isset( $params['loadMonitor'] ) + ? $params['loadMonitor'] : 'LoadMonitor_MySQL'; + + foreach( $params['servers'] as $i => $server ) { + $this->mLoads[$i] = $server['load']; + if ( isset( $server['groupLoads'] ) ) { + foreach ( $server['groupLoads'] as $group => $ratio ) { + if ( !isset( $this->mGroupLoads[$group] ) ) { + $this->mGroupLoads[$group] = array(); + } + $this->mGroupLoads[$group][$i] = $ratio; + } + } + } + } + + static function newFromParams( $servers, $failFunction = false, $waitTimeout = 10 ) + { + return new LoadBalancer( $servers, $failFunction, $waitTimeout ); + } + + /** + * Get a LoadMonitor instance + */ + function getLoadMonitor() { + if ( !isset( $this->mLoadMonitor ) ) { + $class = $this->mLoadMonitorClass; + $this->mLoadMonitor = new $class( $this ); + } + return $this->mLoadMonitor; + } + + /** + * Get or set arbitrary data used by the parent object, usually an LBFactory + */ + function parentInfo( $x = null ) { + return wfSetVar( $this->mParentInfo, $x ); + } + + /** + * Given an array of non-normalised probabilities, this function will select + * an element and return the appropriate key + */ + function pickRandom( $weights ) + { + if ( !is_array( $weights ) || count( $weights ) == 0 ) { + return false; + } + + $sum = array_sum( $weights ); + if ( $sum == 0 ) { + # No loads on any of them + # In previous versions, this triggered an unweighted random selection, + # but this feature has been removed as of April 2006 to allow for strict + # separation of query groups. + return false; + } + $max = mt_getrandmax(); + $rand = mt_rand(0, $max) / $max * $sum; + + $sum = 0; + foreach ( $weights as $i => $w ) { + $sum += $w; + if ( $sum >= $rand ) { + break; + } + } + return $i; + } + + function getRandomNonLagged( $loads, $wiki = false ) { + # Unset excessively lagged servers + $lags = $this->getLagTimes( $wiki ); + foreach ( $lags as $i => $lag ) { + if ( $i != 0 && isset( $this->mServers[$i]['max lag'] ) ) { + if ( $lag === false ) { + wfDebug( "Server #$i is not replicating\n" ); + unset( $loads[$i] ); + } elseif ( $lag > $this->mServers[$i]['max lag'] ) { + wfDebug( "Server #$i is excessively lagged ($lag seconds)\n" ); + unset( $loads[$i] ); + } + } + } + + # Find out if all the slaves with non-zero load are lagged + $sum = 0; + foreach ( $loads as $load ) { + $sum += $load; + } + if ( $sum == 0 ) { + # No appropriate DB servers except maybe the master and some slaves with zero load + # Do NOT use the master + # Instead, this function will return false, triggering read-only mode, + # and a lagged slave will be used instead. + return false; + } + + if ( count( $loads ) == 0 ) { + return false; + } + + #wfDebugLog( 'connect', var_export( $loads, true ) ); + + # Return a random representative of the remainder + return $this->pickRandom( $loads ); + } + + /** + * Get the index of the reader connection, which may be a slave + * This takes into account load ratios and lag times. It should + * always return a consistent index during a given invocation + * + * Side effect: opens connections to databases + */ + function getReaderIndex( $group = false, $wiki = false ) { + global $wgReadOnly, $wgDBClusterTimeout, $wgDBAvgStatusPoll, $wgDBtype; + + # FIXME: For now, only go through all this for mysql databases + if ($wgDBtype != 'mysql') { + return $this->getWriterIndex(); + } + + if ( count( $this->mServers ) == 1 ) { + # Skip the load balancing if there's only one server + return 0; + } elseif ( $group === false and $this->mReadIndex >= 0 ) { + # Shortcut if generic reader exists already + return $this->mReadIndex; + } + + wfProfileIn( __METHOD__ ); + + $totalElapsed = 0; + + # convert from seconds to microseconds + $timeout = $wgDBClusterTimeout * 1e6; + + # Find the relevant load array + if ( $group !== false ) { + if ( isset( $this->mGroupLoads[$group] ) ) { + $nonErrorLoads = $this->mGroupLoads[$group]; + } else { + # No loads for this group, return false and the caller can use some other group + wfDebug( __METHOD__.": no loads for group $group\n" ); + wfProfileOut( __METHOD__ ); + return false; + } + } else { + $nonErrorLoads = $this->mLoads; + } + + if ( !$nonErrorLoads ) { + throw new MWException( "Empty server array given to LoadBalancer" ); + } + + # Scale the configured load ratios according to the dynamic load (if the load monitor supports it) + $this->getLoadMonitor()->scaleLoads( $nonErrorLoads, $group, $wiki ); + + $i = false; + $found = false; + $laggedSlaveMode = false; + + # First try quickly looking through the available servers for a server that + # meets our criteria + do { + $totalThreadsConnected = 0; + $overloadedServers = 0; + $currentLoads = $nonErrorLoads; + while ( count( $currentLoads ) ) { + if ( $wgReadOnly || $this->mAllowLagged || $laggedSlaveMode ) { + $i = $this->pickRandom( $currentLoads ); + } else { + $i = $this->getRandomNonLagged( $currentLoads, $wiki ); + if ( $i === false && count( $currentLoads ) != 0 ) { + # All slaves lagged. Switch to read-only mode + $wgReadOnly = wfMsgNoDBForContent( 'readonly_lag' ); + $i = $this->pickRandom( $currentLoads ); + $laggedSlaveMode = true; + } + } + + if ( $i === false ) { + # pickRandom() returned false + # This is permanent and means the configuration or the load monitor + # wants us to return false. + wfDebugLog( 'connect', __METHOD__.": pickRandom() returned false\n" ); + wfProfileOut( __METHOD__ ); + return false; + } + + wfDebugLog( 'connect', __METHOD__.": Using reader #$i: {$this->mServers[$i]['host']}...\n" ); + $conn = $this->openConnection( $i, $wiki ); + + if ( !$conn ) { + wfDebugLog( 'connect', __METHOD__.": Failed connecting to $i/$wiki\n" ); + unset( $nonErrorLoads[$i] ); + unset( $currentLoads[$i] ); + continue; + } + + // Perform post-connection backoff + $threshold = isset( $this->mServers[$i]['max threads'] ) + ? $this->mServers[$i]['max threads'] : false; + $backoff = $this->getLoadMonitor()->postConnectionBackoff( $conn, $threshold ); + + // Decrement reference counter, we are finished with this connection. + // It will be incremented for the caller later. + if ( $wiki !== false ) { + $this->reuseConnection( $conn ); + } + + if ( $backoff ) { + # Post-connection overload, don't use this server for now + $totalThreadsConnected += $backoff; + $overloadedServers++; + unset( $currentLoads[$i] ); + } else { + # Return this server + break 2; + } + } + + # No server found yet + $i = false; + + # If all servers were down, quit now + if ( !count( $nonErrorLoads ) ) { + wfDebugLog( 'connect', "All servers down\n" ); + break; + } + + # Some servers must have been overloaded + if ( $overloadedServers == 0 ) { + throw new MWException( __METHOD__.": unexpectedly found no overloaded servers" ); + } + # Back off for a while + # Scale the sleep time by the number of connected threads, to produce a + # roughly constant global poll rate + $avgThreads = $totalThreadsConnected / $overloadedServers; + $totalElapsed += $this->sleep( $wgDBAvgStatusPoll * $avgThreads ); + } while ( $totalElapsed < $timeout ); + + if ( $totalElapsed >= $timeout ) { + wfDebugLog( 'connect', "All servers busy\n" ); + $this->mErrorConnection = false; + $this->mLastError = 'All servers busy'; + } + + if ( $i !== false ) { + # Slave connection successful + # Wait for the session master pos for a short time + if ( $this->mWaitForPos && $i > 0 ) { + if ( !$this->doWait( $i ) ) { + $this->mServers[$i]['slave pos'] = $conn->getSlavePos(); + } + } + if ( $this->mReadIndex <=0 && $this->mLoads[$i]>0 && $i !== false ) { + $this->mReadIndex = $i; + } + } + wfProfileOut( __METHOD__ ); + return $i; + } + + /** + * Wait for a specified number of microseconds, and return the period waited + */ + function sleep( $t ) { + wfProfileIn( __METHOD__ ); + wfDebug( __METHOD__.": waiting $t us\n" ); + usleep( $t ); + wfProfileOut( __METHOD__ ); + return $t; + } + + /** + * Get a random server to use in a query group + * @deprecated use getReaderIndex + */ + function getGroupIndex( $group ) { + return $this->getReaderIndex( $group ); + } + + /** + * Set the master wait position + * If a DB_SLAVE connection has been opened already, waits + * Otherwise sets a variable telling it to wait if such a connection is opened + */ + public function waitFor( $pos ) { + wfProfileIn( __METHOD__ ); + $this->mWaitForPos = $pos; + $i = $this->mReadIndex; + + if ( $i > 0 ) { + if ( !$this->doWait( $i ) ) { + $this->mServers[$i]['slave pos'] = $this->getAnyOpenConnection( $i )->getSlavePos(); + $this->mLaggedSlaveMode = true; + } + } + wfProfileOut( __METHOD__ ); + } + + /** + * Get any open connection to a given server index, local or foreign + * Returns false if there is no connection open + */ + function getAnyOpenConnection( $i ) { + foreach ( $this->mConns as $type => $conns ) { + if ( !empty( $conns[$i] ) ) { + return reset( $conns[$i] ); + } + } + return false; + } + + /** + * Wait for a given slave to catch up to the master pos stored in $this + */ + function doWait( $index ) { + # Find a connection to wait on + $conn = $this->getAnyOpenConnection( $index ); + if ( !$conn ) { + wfDebug( __METHOD__ . ": no connection open\n" ); + return false; + } + + wfDebug( __METHOD__.": Waiting for slave #$index to catch up...\n" ); + $result = $conn->masterPosWait( $this->mWaitForPos, $this->mWaitTimeout ); + + if ( $result == -1 || is_null( $result ) ) { + # Timed out waiting for slave, use master instead + wfDebug( __METHOD__.": Timed out waiting for slave #$index pos {$this->mWaitForPos}\n" ); + return false; + } else { + wfDebug( __METHOD__.": Done\n" ); + return true; + } + } + + /** + * Get a connection by index + * This is the main entry point for this class. + */ + public function &getConnection( $i, $groups = array(), $wiki = false ) { + global $wgDBtype; + wfProfileIn( __METHOD__ ); + + if ( $wiki === wfWikiID() ) { + $wiki = false; + } + + # Query groups + if ( $i == DB_MASTER ) { + $i = $this->getWriterIndex(); + } elseif ( !is_array( $groups ) ) { + $groupIndex = $this->getReaderIndex( $groups, $wiki ); + if ( $groupIndex !== false ) { + $serverName = $this->getServerName( $groupIndex ); + wfDebug( __METHOD__.": using server $serverName for group $groups\n" ); + $i = $groupIndex; + } + } else { + foreach ( $groups as $group ) { + $groupIndex = $this->getReaderIndex( $group, $wiki ); + if ( $groupIndex !== false ) { + $serverName = $this->getServerName( $groupIndex ); + wfDebug( __METHOD__.": using server $serverName for group $group\n" ); + $i = $groupIndex; + break; + } + } + } + + # Operation-based index + if ( $i == DB_SLAVE ) { + $i = $this->getReaderIndex( false, $wiki ); + } elseif ( $i == DB_LAST ) { + # Just use $this->mLastIndex, which should already be set + $i = $this->mLastIndex; + if ( $i === -1 ) { + # Oh dear, not set, best to use the writer for safety + wfDebug( "Warning: DB_LAST used when there was no previous index\n" ); + $i = $this->getWriterIndex(); + } + } + # Couldn't find a working server in getReaderIndex()? + if ( $i === false ) { + $this->reportConnectionError( $this->mErrorConnection ); + } + + # Now we have an explicit index into the servers array + $conn = $this->openConnection( $i, $wiki ); + if ( !$conn ) { + $this->reportConnectionError( $this->mErrorConnection ); + } + + wfProfileOut( __METHOD__ ); + return $conn; + } + + /** + * Mark a foreign connection as being available for reuse under a different + * DB name or prefix. This mechanism is reference-counted, and must be called + * the same number of times as getConnection() to work. + */ + public function reuseConnection( $conn ) { + $serverIndex = $conn->getLBInfo('serverIndex'); + $refCount = $conn->getLBInfo('foreignPoolRefCount'); + $dbName = $conn->getDBname(); + $prefix = $conn->tablePrefix(); + if ( strval( $prefix ) !== '' ) { + $wiki = "$dbName-$prefix"; + } else { + $wiki = $dbName; + } + if ( $serverIndex === null || $refCount === null ) { + wfDebug( __METHOD__.": this connection was not opened as a foreign connection\n" ); + /** + * This can happen in code like: + * foreach ( $dbs as $db ) { + * $conn = $lb->getConnection( DB_SLAVE, array(), $db ); + * ... + * $lb->reuseConnection( $conn ); + * } + * When a connection to the local DB is opened in this way, reuseConnection() + * should be ignored + */ + return; + } + if ( $this->mConns['foreignUsed'][$serverIndex][$wiki] !== $conn ) { + throw new MWException( __METHOD__.": connection not found, has the connection been freed already?" ); + } + $conn->setLBInfo( 'foreignPoolRefCount', --$refCount ); + if ( $refCount <= 0 ) { + $this->mConns['foreignFree'][$serverIndex][$wiki] = $conn; + unset( $this->mConns['foreignUsed'][$serverIndex][$wiki] ); + wfDebug( __METHOD__.": freed connection $serverIndex/$wiki\n" ); + } else { + wfDebug( __METHOD__.": reference count for $serverIndex/$wiki reduced to $refCount\n" ); + } + } + + /** + * Open a connection to the server given by the specified index + * Index must be an actual index into the array. + * If the server is already open, returns it. + * + * On error, returns false, and the connection which caused the + * error will be available via $this->mErrorConnection. + * + * @param integer $i Server index + * @param string $wiki Wiki ID to open + * @return Database + * + * @access private + */ + function openConnection( $i, $wiki = false ) { + wfProfileIn( __METHOD__ ); + if ( $wiki !== false ) { + $conn = $this->openForeignConnection( $i, $wiki ); + wfProfileOut( __METHOD__); + return $conn; + } + if ( isset( $this->mConns['local'][$i][0] ) ) { + $conn = $this->mConns['local'][$i][0]; + } else { + $server = $this->mServers[$i]; + $server['serverIndex'] = $i; + $conn = $this->reallyOpenConnection( $server ); + if ( $conn->isOpen() ) { + $this->mConns['local'][$i][0] = $conn; + } else { + wfDebug( "Failed to connect to database $i at {$this->mServers[$i]['host']}\n" ); + $this->mErrorConnection = $conn; + $conn = false; + } + } + $this->mLastIndex = $i; + wfProfileOut( __METHOD__ ); + return $conn; + } + + /** + * Open a connection to a foreign DB, or return one if it is already open. + * + * Increments a reference count on the returned connection which locks the + * connection to the requested wiki. This reference count can be + * decremented by calling reuseConnection(). + * + * If a connection is open to the appropriate server already, but with the wrong + * database, it will be switched to the right database and returned, as long as + * it has been freed first with reuseConnection(). + * + * On error, returns false, and the connection which caused the + * error will be available via $this->mErrorConnection. + * + * @param integer $i Server index + * @param string $wiki Wiki ID to open + * @return Database + */ + function openForeignConnection( $i, $wiki ) { + wfProfileIn(__METHOD__); + list( $dbName, $prefix ) = wfSplitWikiID( $wiki ); + if ( isset( $this->mConns['foreignUsed'][$i][$wiki] ) ) { + // Reuse an already-used connection + $conn = $this->mConns['foreignUsed'][$i][$wiki]; + wfDebug( __METHOD__.": reusing connection $i/$wiki\n" ); + } elseif ( isset( $this->mConns['foreignFree'][$i][$wiki] ) ) { + // Reuse a free connection for the same wiki + $conn = $this->mConns['foreignFree'][$i][$wiki]; + unset( $this->mConns['foreignFree'][$i][$wiki] ); + $this->mConns['foreignUsed'][$i][$wiki] = $conn; + wfDebug( __METHOD__.": reusing free connection $i/$wiki\n" ); + } elseif ( !empty( $this->mConns['foreignFree'][$i] ) ) { + // Reuse a connection from another wiki + $conn = reset( $this->mConns['foreignFree'][$i] ); + $oldWiki = key( $this->mConns['foreignFree'][$i] ); + + if ( !$conn->selectDB( $dbName ) ) { + global $wguname; + $this->mLastError = "Error selecting database $dbName on server " . + $conn->getServer() . " from client host {$wguname['nodename']}\n"; + $this->mErrorConnection = $conn; + $conn = false; + } else { + $conn->tablePrefix( $prefix ); + unset( $this->mConns['foreignFree'][$i][$oldWiki] ); + $this->mConns['foreignUsed'][$i][$wiki] = $conn; + wfDebug( __METHOD__.": reusing free connection from $oldWiki for $wiki\n" ); + } + } else { + // Open a new connection + $server = $this->mServers[$i]; + $server['serverIndex'] = $i; + $server['foreignPoolRefCount'] = 0; + $conn = $this->reallyOpenConnection( $server, $dbName ); + if ( !$conn->isOpen() ) { + wfDebug( __METHOD__.": error opening connection for $i/$wiki\n" ); + $this->mErrorConnection = $conn; + $conn = false; + } else { + $this->mConns['foreignUsed'][$i][$wiki] = $conn; + wfDebug( __METHOD__.": opened new connection for $i/$wiki\n" ); + } + } + + // Increment reference count + if ( $conn ) { + $refCount = $conn->getLBInfo( 'foreignPoolRefCount' ); + $conn->setLBInfo( 'foreignPoolRefCount', $refCount + 1 ); + } + wfProfileOut(__METHOD__); + return $conn; + } + + /** + * Test if the specified index represents an open connection + * @access private + */ + function isOpen( $index ) { + if( !is_integer( $index ) ) { + return false; + } + return (bool)$this->getAnyOpenConnection( $index ); + } + + /** + * Really opens a connection. Uncached. + * Returns a Database object whether or not the connection was successful. + * @access private + */ + function reallyOpenConnection( $server, $dbNameOverride = false ) { + if( !is_array( $server ) ) { + throw new MWException( 'You must update your load-balancing configuration. See DefaultSettings.php entry for $wgDBservers.' ); + } + + extract( $server ); + if ( $dbNameOverride !== false ) { + $dbname = $dbNameOverride; + } + + # Get class for this database type + $class = 'Database' . ucfirst( $type ); + + # Create object + wfDebug( "Connecting to $host $dbname...\n" ); + $db = new $class( $host, $user, $password, $dbname, 1, $flags ); + if ( $db->isOpen() ) { + wfDebug( "Connected\n" ); + } else { + wfDebug( "Failed\n" ); + } + $db->setLBInfo( $server ); + if ( isset( $server['fakeSlaveLag'] ) ) { + $db->setFakeSlaveLag( $server['fakeSlaveLag'] ); + } + if ( isset( $server['fakeMaster'] ) ) { + $db->setFakeMaster( true ); + } + return $db; + } + + function reportConnectionError( &$conn ) { + wfProfileIn( __METHOD__ ); + # Prevent infinite recursion + + static $reporting = false; + if ( !$reporting ) { + $reporting = true; + if ( !is_object( $conn ) ) { + // No last connection, probably due to all servers being too busy + $conn = new Database; + if ( $this->mFailFunction ) { + $conn->failFunction( $this->mFailFunction ); + $conn->reportConnectionError( $this->mLastError ); + } else { + // If all servers were busy, mLastError will contain something sensible + throw new DBConnectionError( $conn, $this->mLastError ); + } + } else { + if ( $this->mFailFunction ) { + $conn->failFunction( $this->mFailFunction ); + } else { + $conn->failFunction( false ); + } + $server = $conn->getProperty( 'mServer' ); + $conn->reportConnectionError( "{$this->mLastError} ({$server})" ); + } + $reporting = false; + } + wfProfileOut( __METHOD__ ); + } + + function getWriterIndex() { + return 0; + } + + /** + * Returns true if the specified index is a valid server index + */ + function haveIndex( $i ) { + return array_key_exists( $i, $this->mServers ); + } + + /** + * Returns true if the specified index is valid and has non-zero load + */ + function isNonZeroLoad( $i ) { + return array_key_exists( $i, $this->mServers ) && $this->mLoads[$i] != 0; + } + + /** + * Get the number of defined servers (not the number of open connections) + */ + function getServerCount() { + return count( $this->mServers ); + } + + /** + * Get the host name or IP address of the server with the specified index + * Prefer a readable name if available. + */ + function getServerName( $i ) { + if ( isset( $this->mServers[$i]['hostName'] ) ) { + return $this->mServers[$i]['hostName']; + } elseif ( isset( $this->mServers[$i]['host'] ) ) { + return $this->mServers[$i]['host']; + } else { + return ''; + } + } + + /** + * Return the server info structure for a given index, or false if the index is invalid. + */ + function getServerInfo( $i ) { + if ( isset( $this->mServers[$i] ) ) { + return $this->mServers[$i]; + } else { + return false; + } + } + + /** + * Get the current master position for chronology control purposes + * @return mixed + */ + function getMasterPos() { + # If this entire request was served from a slave without opening a connection to the + # master (however unlikely that may be), then we can fetch the position from the slave. + $masterConn = $this->getAnyOpenConnection( 0 ); + if ( !$masterConn ) { + for ( $i = 1; $i < count( $this->mServers ); $i++ ) { + $conn = $this->getAnyOpenConnection( $i ); + if ( $conn ) { + wfDebug( "Master pos fetched from slave\n" ); + return $conn->getSlavePos(); + } + } + } else { + wfDebug( "Master pos fetched from master\n" ); + return $masterConn->getMasterPos(); + } + return false; + } + + /** + * Close all open connections + */ + function closeAll() { + foreach ( $this->mConns as $conns2 ) { + foreach ( $conns2 as $conns3 ) { + foreach ( $conns3 as $conn ) { + $conn->close(); + } + } + } + $this->mConns = array( + 'local' => array(), + 'foreignFree' => array(), + 'foreignUsed' => array(), + ); + } + + /** + * Close a connection + * Using this function makes sure the LoadBalancer knows the connection is closed. + * If you use $conn->close() directly, the load balancer won't update its state. + */ + function closeConnecton( $conn ) { + $done = false; + foreach ( $this->mConns as $i1 => $conns2 ) { + foreach ( $conns2 as $i2 => $conns3 ) { + foreach ( $conns3 as $i3 => $candidateConn ) { + if ( $conn === $candidateConn ) { + $conn->close(); + unset( $this->mConns[$i1][$i2][$i3] ); + $done = true; + break; + } + } + } + } + if ( !$done ) { + $conn->close(); + } + } + + /** + * Commit transactions on all open connections + */ + function commitAll() { + foreach ( $this->mConns as $conns2 ) { + foreach ( $conns2 as $conns3 ) { + foreach ( $conns3 as $conn ) { + $conn->immediateCommit(); + } + } + } + } + + /* Issue COMMIT only on master, only if queries were done on connection */ + function commitMasterChanges() { + // Always 0, but who knows.. :) + $masterIndex = $this->getWriterIndex(); + foreach ( $this->mConns as $type => $conns2 ) { + if ( empty( $conns2[$masterIndex] ) ) { + continue; + } + foreach ( $conns2[$masterIndex] as $conn ) { + if ( $conn->lastQuery() != '' ) { + $conn->commit(); + } + } + } + } + + function waitTimeout( $value = NULL ) { + return wfSetVar( $this->mWaitTimeout, $value ); + } + + function getLaggedSlaveMode() { + return $this->mLaggedSlaveMode; + } + + /* Disables/enables lag checks */ + function allowLagged($mode=null) { + if ($mode===null) + return $this->mAllowLagged; + $this->mAllowLagged=$mode; + } + + function pingAll() { + $success = true; + foreach ( $this->mConns as $conns2 ) { + foreach ( $conns2 as $conns3 ) { + foreach ( $conns3 as $conn ) { + if ( !$conn->ping() ) { + $success = false; + } + } + } + } + return $success; + } + + /** + * Call a function with each open connection object + */ + function forEachOpenConnection( $callback, $params = array() ) { + foreach ( $this->mConns as $conns2 ) { + foreach ( $conns2 as $conns3 ) { + foreach ( $conns3 as $conn ) { + $mergedParams = array_merge( array( $conn ), $params ); + call_user_func_array( $callback, $mergedParams ); + } + } + } + } + + /** + * Get the hostname and lag time of the most-lagged slave. + * This is useful for maintenance scripts that need to throttle their updates. + * May attempt to open connections to slaves on the default DB. + */ + function getMaxLag() { + $maxLag = -1; + $host = ''; + foreach ( $this->mServers as $i => $conn ) { + $conn = $this->getAnyOpenConnection( $i ); + if ( !$conn ) { + $conn = $this->openConnection( $i ); + } + if ( !$conn ) { + continue; + } + $lag = $conn->getLag(); + if ( $lag > $maxLag ) { + $maxLag = $lag; + $host = $this->mServers[$i]['host']; + } + } + return array( $host, $maxLag ); + } + + /** + * Get lag time for each server + * Results are cached for a short time in memcached, and indefinitely in the process cache + */ + function getLagTimes( $wiki = false ) { + # Try process cache + if ( isset( $this->mLagTimes ) ) { + return $this->mLagTimes; + } + # No, send the request to the load monitor + $this->mLagTimes = $this->getLoadMonitor()->getLagTimes( array_keys( $this->mServers ), $wiki ); + return $this->mLagTimes; + } +} diff --git a/includes/db/LoadMonitor.php b/includes/db/LoadMonitor.php new file mode 100644 index 00000000..8e16f1a1 --- /dev/null +++ b/includes/db/LoadMonitor.php @@ -0,0 +1,121 @@ +<?php + +/** + * An interface for database load monitoring + */ + +interface LoadMonitor { + /** + * Construct a new LoadMonitor with a given LoadBalancer parent + */ + function __construct( $parent ); + + /** + * Perform pre-connection load ratio adjustment. + * @param array $loads + * @param string $group The selected query group + * @param string $wiki + */ + function scaleLoads( &$loads, $group = false, $wiki = false ); + + /** + * Perform post-connection backoff. + * + * If the connection is in overload, this should return a backoff factor + * which will be used to control polling time. The number of threads + * connected is a good measure. + * + * If there is no overload, zero can be returned. + * + * A threshold thread count is given, the concrete class may compare this + * to the running thread count. The threshold may be false, which indicates + * that the sysadmin has not configured this feature. + * + * @param Database $conn + * @param float $threshold + */ + function postConnectionBackoff( $conn, $threshold ); + + /** + * Return an estimate of replication lag for each server + */ + function getLagTimes( $serverIndexes, $wiki ); +} + + +/** + * Basic MySQL load monitor with no external dependencies + * Uses memcached to cache the replication lag for a short time + */ + +class LoadMonitor_MySQL implements LoadMonitor { + var $parent; // LoadBalancer + + function __construct( $parent ) { + $this->parent = $parent; + } + + function scaleLoads( &$loads, $group = false, $wiki = false ) { + } + + function getLagTimes( $serverIndexes, $wiki ) { + wfProfileIn( __METHOD__ ); + $expiry = 5; + $requestRate = 10; + + global $wgMemc; + $masterName = $this->parent->getServerName( 0 ); + $memcKey = wfMemcKey( 'lag_times', $masterName ); + $times = $wgMemc->get( $memcKey ); + if ( $times ) { + # Randomly recache with probability rising over $expiry + $elapsed = time() - $times['timestamp']; + $chance = max( 0, ( $expiry - $elapsed ) * $requestRate ); + if ( mt_rand( 0, $chance ) != 0 ) { + unset( $times['timestamp'] ); + wfProfileOut( __METHOD__ ); + return $times; + } + wfIncrStats( 'lag_cache_miss_expired' ); + } else { + wfIncrStats( 'lag_cache_miss_absent' ); + } + + # Cache key missing or expired + + $times = array(); + foreach ( $serverIndexes as $i ) { + if ($i == 0) { # Master + $times[$i] = 0; + } elseif ( false !== ( $conn = $this->parent->getAnyOpenConnection( $i ) ) ) { + $times[$i] = $conn->getLag(); + } elseif ( false !== ( $conn = $this->parent->openConnection( $i, $wiki ) ) ) { + $times[$i] = $conn->getLag(); + } + } + + # Add a timestamp key so we know when it was cached + $times['timestamp'] = time(); + $wgMemc->set( $memcKey, $times, $expiry ); + + # But don't give the timestamp to the caller + unset($times['timestamp']); + $lagTimes = $times; + + wfProfileOut( __METHOD__ ); + return $lagTimes; + } + + function postConnectionBackoff( $conn, $threshold ) { + if ( !$threshold ) { + return 0; + } + $status = $conn->getStatus("Thread%"); + if ( $status['Threads_running'] > $threshold ) { + return $status['Threads_connected']; + } else { + return 0; + } + } +} + |