/** Maximum time to wait before retry */
define( 'DEADLOCK_DELAY_MAX', 1500000 );
+/**
+ * Base interface for all DBMS-specific code. At a bare minimum, all of the
+ * following must be implemented to support MediaWiki
+ *
+ * @file
+ * @ingroup Database
+ */
+interface DatabaseType {
+ /**
+ * Get the type of the DBMS, as it appears in $wgDBtype.
+ *
+ * @return string
+ */
+ function getType();
+
+ /**
+ * Open a connection to the database. Usually aborts on failure
+ *
+ * @param $server String: database server host
+ * @param $user String: database user name
+ * @param $password String: database user password
+ * @param $dbName String: database name
+ * @return bool
+ * @throws DBConnectionError
+ */
+ function open( $server, $user, $password, $dbName );
+
+ /**
+ * The DBMS-dependent part of query()
+ * @todo Fixme: Make this private someday
+ *
+ * @param $sql String: SQL query.
+ * @return Result object to feed to fetchObject, fetchRow, ...; or false on failure
+ * @private
+ */
+ function doQuery( $sql );
+
+ /**
+ * 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 DatabaseBase::query(), etc.
+ * @return Row object
+ * @throws DBUnexpectedError Thrown if the database returns an error
+ */
+ function fetchObject( $res );
+
+ /**
+ * 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 DatabaseBase::query(), etc.
+ * @return Row object
+ * @throws DBUnexpectedError Thrown if the database returns an error
+ */
+ function fetchRow( $res );
+
+ /**
+ * Get the number of rows in a result object
+ *
+ * @param $res Mixed: A SQL result
+ * @return int
+ */
+ function numRows( $res );
+
+ /**
+ * Get the number of fields in a result object
+ * @see http://www.php.net/mysql_num_fields
+ *
+ * @param $res Mixed: A SQL result
+ * @return int
+ */
+ function numFields( $res );
+
+ /**
+ * Get a field name in a result object
+ * @see http://www.php.net/mysql_field_name
+ *
+ * @param $res Mixed: A SQL result
+ * @param $n Integer
+ * @return string
+ */
+ function fieldName( $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();
+ *
+ * @return int
+ */
+ function insertId();
+
+ /**
+ * Change the position of the cursor in a result object
+ * @see http://www.php.net/mysql_data_seek
+ *
+ * @param $res Mixed: A SQL result
+ * @param $row Mixed: Either MySQL row or ResultWrapper
+ */
+ function dataSeek( $res, $row );
+
+ /**
+ * Get the last error number
+ * @see http://www.php.net/mysql_errno
+ *
+ * @return int
+ */
+ function lastErrno();
+
+ /**
+ * Get a description of the last error
+ * @see http://www.php.net/mysql_error
+ *
+ * @return string
+ */
+ function lastError();
+
+ /**
+ * mysql_fetch_field() wrapper
+ * Returns false if the field doesn't exist
+ *
+ * @param $table string: table name
+ * @param $field string: field name
+ */
+ function fieldInfo( $table, $field );
+
+ /**
+ * Get information about an index into an object
+ * @param $table string: Table name
+ * @param $index string: Index name
+ * @param $fname string: Calling function name
+ * @return Mixed: Database-specific index description class or false if the index does not exist
+ */
+ function indexInfo( $table, $index, $fname = 'Database::indexInfo' );
+
+ /**
+ * Get the number of rows affected by the last write query
+ * @see http://www.php.net/mysql_affected_rows
+ *
+ * @return int
+ */
+ function affectedRows();
+
+ /**
+ * Wrapper for addslashes()
+ *
+ * @param $s string: to be slashed.
+ * @return string: slashed string.
+ */
+ function strencode( $s );
+
+ /**
+ * Returns a wikitext link to the DB's website, e.g.,
+ * return "[http://www.mysql.com/ MySQL]";
+ * Should at least contain plain text, if for some reason
+ * your database has no website.
+ *
+ * @return string: wikitext of a link to the server software's web site
+ */
+ static function getSoftwareLink();
+
+ /**
+ * A string describing the current software version, like from
+ * mysql_get_server_info().
+ *
+ * @return string: Version information from the database server.
+ */
+ function getServerVersion();
+
+ /**
+ * A string describing the current software version, and possibly
+ * other details in a user-friendly way. Will be listed on Special:Version, etc.
+ * Use getServerVersion() to get machine-friendly information.
+ *
+ * @return string: Version information from the database server
+ */
+ function getServerInfo();
+}
+
/**
* Database abstraction object
* @ingroup Database
*/
-abstract class DatabaseBase {
+abstract class DatabaseBase implements DatabaseType {
-#------------------------------------------------------------------------------
+# ------------------------------------------------------------------------------
# Variables
-#------------------------------------------------------------------------------
+# ------------------------------------------------------------------------------
protected $mLastQuery = '';
protected $mDoneWrites = false;
protected $mServer, $mUser, $mPassword, $mConn = null, $mDBname;
protected $mOpened = false;
- protected $mFailFunction;
protected $mTablePrefix;
protected $mFlags;
protected $mTrxLevel = 0;
protected $mFakeSlaveLag = null, $mFakeMaster = false;
protected $mDefaultBigSelects = null;
-#------------------------------------------------------------------------------
+# ------------------------------------------------------------------------------
# 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
+ * A string describing the current software version, and possibly
+ * other details in a user-friendly way. Will be listed on Special:Version, etc.
+ * Use getServerVersion() to get machine-friendly information.
+ *
+ * @return string: Version information from the database server
*/
- function failFunction( $function = null ) {
- return wfSetVar( $this->mFailFunction, $function );
+ public function getServerInfo() {
+ return $this->getServerVersion();
}
/**
}
function tablePrefix( $prefix = null ) {
- return wfSetVar( $this->mTablePrefix, $prefix );
+ return wfSetVar( $this->mTablePrefix, $prefix, true );
}
/**
/**
* Returns true if this database requires that SELECT DISTINCT queries require that all
- ORDER BY expressions occur in the SELECT list per the SQL92 standard
+ ORDER BY expressions occur in the SELECT list per the SQL92 standard
*/
function standardSelectDistinct() {
return true;
* @return Boolean
*/
function getFlag( $flag ) {
- return !!($this->mFlags & $flag);
+ return !!( $this->mFlags & $flag );
}
/**
}
function getWikiID() {
- if( $this->mTablePrefix ) {
+ if ( $this->mTablePrefix ) {
return "{$this->mDBname}-{$this->mTablePrefix}";
} else {
return $this->mDBname;
}
/**
- * Get the type of the DBMS, as it appears in $wgDBtype.
+ * Return a path to the DBMS-specific schema, otherwise default to tables.sql
*/
- abstract function getType();
+ public function getSchema() {
+ global $IP;
+ if ( file_exists( "$IP/maintenance/" . $this->getType() . "/tables.sql" ) ) {
+ return "$IP/maintenance/" . $this->getType() . "/tables.sql";
+ } else {
+ return "$IP/maintenance/tables.sql";
+ }
+ }
-#------------------------------------------------------------------------------
+# ------------------------------------------------------------------------------
# Other functions
-#------------------------------------------------------------------------------
+# ------------------------------------------------------------------------------
/**
* Constructor.
* @param $user String: database user name
* @param $password String: database user password
* @param $dbName String: 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' ) {
-
+ $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 ) {
}
}
- /*
- // 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;
* @param $user String: database user name
* @param $password String: database user password
* @param $dbName String: database name
- * @param failFunction
* @param $flags
*/
- static function newFromParams( $server, $user, $password, $dbName, $failFunction = false, $flags = 0 )
- {
+ static function newFromParams( $server, $user, $password, $dbName, $flags = 0 ) {
wfDeprecated( __METHOD__ );
- return new DatabaseMysql( $server, $user, $password, $dbName, $failFunction, $flags );
+ return new DatabaseMysql( $server, $user, $password, $dbName, $flags );
}
/**
- * Usually aborts on failure
- * If the failFunction is set to a non-zero integer, returns success
- * @param $server String: database server host
- * @param $user String: database user name
- * @param $password String: database user password
- * @param $dbName String: database name
+ * Given a DB type, construct the name of the appropriate child class of
+ * DatabaseBase. This is designed to replace all of the manual stuff like:
+ * $class = 'Database' . ucfirst( strtolower( $type ) );
+ * as well as validate against the canonical list of DB types we have
+ *
+ * @param $dbType String A possible DB type
+ * @return DatabaseBase subclass or null
*/
- abstract function open( $server, $user, $password, $dbName );
+ public final static function classFromType( $dbType ) {
+ $canonicalDBTypes = array(
+ 'mysql', 'postgres', 'sqlite', 'oracle', 'mssql', 'ibm_db2'
+ );
+ $dbType = strtolower( $dbType );
+ if( in_array( $dbType, $canonicalDBTypes ) ) {
+ return 'Database' . ucfirst( $dbType );
+ } else {
+ return null;
+ }
+ }
protected function installErrorHandler() {
$this->mPHPError = false;
$error = $myError;
}
- if ( $this->mFailFunction ) {
- # Legacy error handling method
- if ( !is_int( $this->mFailFunction ) ) {
- $ff = $this->mFailFunction;
- $ff( $this, $error );
- }
- } else {
- # New method
- throw new DBConnectionError( $this, $error );
- }
+ # New method
+ throw new DBConnectionError( $this, $error );
}
/**
* comment (you can use __METHOD__ or add some extra info)
* @param $tempIgnore Boolean: 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,
+ * @return boolean or ResultWrapper. 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
*/
# 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( DatabaseBase::generalizeSQL( $sql ), 0, 255 );
+ # $profName = 'query: ' . $fname . ' ' . substr( DatabaseBase::generalizeSQL( $sql ), 0, 255 );
if ( $isMaster ) {
$queryProf = 'query-m: ' . substr( DatabaseBase::generalizeSQL( $sql ), 0, 255 );
$queryProf = 'query: ' . substr( DatabaseBase::generalizeSQL( $sql ), 0, 255 );
$totalProf = 'DatabaseBase::query';
}
+
wfProfileIn( $totalProf );
wfProfileIn( $queryProf );
}
$this->mLastQuery = $sql;
if ( !$this->mDoneWrites && $this->isWriteQuery( $sql ) ) {
// Set a flag indicating that writes have been done
- wfDebug( __METHOD__.": Writes done: $sql\n" );
+ wfDebug( __METHOD__ . ": Writes done: $sql\n" );
$this->mDoneWrites = true;
}
# Add a comment for easy SHOW PROCESSLIST interpretation
- #if ( $fname ) {
+ # if ( $fname ) {
global $wgUser;
- if ( is_object( $wgUser ) && !($wgUser instanceof StubObject) ) {
+ if ( is_object( $wgUser ) && $wgUser->mDataLoaded ) {
$userName = $wgUser->getName();
if ( mb_strlen( $userName ) > 15 ) {
$userName = mb_substr( $userName, 0, 15 ) . '...';
} else {
$userName = '';
}
- $commentedSql = preg_replace('/\s/', " /* $fname $userName */ ", $sql, 1);
- #} else {
+ $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') {
+ $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)
+ $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() ) {
static $cnt = 0;
+
$cnt++;
$sqlx = substr( $commentedSql, 0, 500 );
$sqlx = strtr( $sqlx, "\t\n", ' ' );
+
if ( $isMaster ) {
wfDebug( "Query $cnt (master): $sqlx\n" );
} else {
# 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 );
+ $elapsed = round( microtime( true ) - $wgRequestTime, 3 );
wfLogDBError( "Connection lost and reconnected after {$elapsed}s, query: $sqlx\n" );
$ret = $this->doQuery( $commentedSql );
} else {
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
- * @private
- */
- /*private*/ abstract function doQuery( $sql );
-
/**
* @param $error String
* @param $errno Integer
$ignore = $this->ignoreErrors( true );
++$this->mErrorCount;
- if( $ignore || $tempIgnore ) {
- wfDebug("SQL ERROR (ignored): $error\n");
+ 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");
+ 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 );
}
}
* @param $args Mixed: Either an array here, or put scalars as varargs
*/
function execute( $prepared, $args = null ) {
- if( !is_array( $args ) ) {
+ 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'] );
}
*/
function safeQuery( $query, $args = null ) {
$prepared = $this->prepare( $query, 'DatabaseBase::safeQuery' );
- if( !is_array( $args ) ) {
+
+ 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;
}
function fillPrepared( $preparedQuery, $args ) {
reset( $args );
$this->preparedArgs =& $args;
+
return preg_replace_callback( '/(\\\\[?!&]|[?!&])/',
array( &$this, 'fillPreparedArg' ), $preparedQuery );
}
case '\\!': return '!';
case '\\&': return '&';
}
+
list( /* $n */ , $arg ) = each( $this->preparedArgs );
+
switch( $matches[1] ) {
case '?': return $this->addQuotes( $arg );
case '!': return $arg;
# be freed by PHP when the variable goes out of scope anyway.
}
- /**
- * 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 DatabaseBase::query(), etc.
- * @return Row object
- * @throws DBUnexpectedError Thrown if the database returns an error
- */
- abstract function fetchObject( $res );
-
- /**
- * 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 DatabaseBase::query(), etc.
- * @return Row object
- * @throws DBUnexpectedError Thrown if the database returns an error
- */
- abstract function fetchRow( $res );
-
- /**
- * Get the number of rows in a result object
- * @param $res Mixed: A SQL result
- */
- abstract function numRows( $res );
-
- /**
- * Get the number of fields in a result object
- * See documentation for mysql_num_fields()
- * @param $res Mixed: A SQL result
- */
- abstract function numFields( $res );
-
- /**
- * Get a field name in a result object
- * See documentation for mysql_field_name():
- * http://www.php.net/mysql_field_name
- * @param $res Mixed: A SQL result
- * @param $n Integer
- */
- abstract function fieldName( $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();
- */
- abstract function insertId();
-
- /**
- * Change the position of the cursor in a result object
- * See mysql_data_seek()
- * @param $res Mixed: A SQL result
- * @param $row Mixed: Either MySQL row or ResultWrapper
- */
- abstract function dataSeek( $res, $row );
-
- /**
- * Get the last error number
- * See mysql_errno()
- */
- abstract function lastErrno();
-
- /**
- * Get a description of the last error
- * See mysql_error() for more details
- */
- abstract function lastError();
-
- /**
- * Get the number of rows affected by the last write query
- * See mysql_affected_rows() for more details
- */
- abstract function affectedRows();
-
/**
* Simple UPDATE wrapper
* Usually aborts on failure
$table = $this->tableName( $table );
$sql = "UPDATE $table SET $var = '" .
$this->strencode( $value ) . "' WHERE ($cond)";
+
return (bool)$this->query( $sql, $fname );
}
* Usually aborts on failure
* If errors are explicitly ignored, returns FALSE on failure
*/
- function selectField( $table, $var, $cond='', $fname = 'DatabaseBase::selectField', $options = array() ) {
+ function selectField( $table, $var, $cond = '', $fname = 'DatabaseBase::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 ) {
return reset( $row );
} else {
$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['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'])) {
+ // 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';
+ 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( $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'] );
* (e.g. array( 'page' => array('LEFT JOIN','page_latest=rev_id') )
* @return mixed Database result resource (feed to DatabaseBase::fetchObject or whatever), or false on failure
*/
- function select( $table, $vars, $conds='', $fname = 'DatabaseBase::select', $options = array(), $join_conds = array() )
- {
+ function select( $table, $vars, $conds = '', $fname = 'DatabaseBase::select', $options = array(), $join_conds = array() ) {
$sql = $this->selectSQLText( $table, $vars, $conds, $fname, $options, $join_conds );
+
return $this->query( $sql, $fname );
}
/**
* SELECT wrapper
*
- * @param $table Mixed: Array or string, table name(s) (prefix auto-added)
+ * @param $table Mixed: Array or string, table name(s) (prefix auto-added). Array keys are table aliases (optional)
* @param $vars Mixed: Array or string, field name(s) to be retrieved
* @param $conds Mixed: Array or string, condition(s) for WHERE
* @param $fname String: Calling function name (use __METHOD__) for logs/profiling
* (e.g. array( 'page' => array('LEFT JOIN','page_latest=rev_id') )
* @return string, the SQL text
*/
- function selectSQLText( $table, $vars, $conds='', $fname = 'DatabaseBase::select', $options = array(), $join_conds = array() ) {
- if( is_array( $vars ) ) {
+ function selectSQLText( $table, $vars, $conds = '', $fname = 'DatabaseBase::select', $options = array(), $join_conds = array() ) {
+ if ( is_array( $vars ) ) {
$vars = implode( ',', $vars );
}
- if( !is_array( $options ) ) {
+
+ if ( !is_array( $options ) ) {
$options = array( $options );
}
- if( is_array( $table ) ) {
- if ( !empty($join_conds) || ( isset( $options['USE INDEX'] ) && is_array( @$options['USE INDEX'] ) ) )
+
+ 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}==' ') {
+ } else {
+ $from = ' FROM ' . implode( ',', $this->tableNamesWithAlias( $table ) );
+ }
+ } elseif ( $table != '' ) {
+ if ( $table { 0 } == ' ' ) {
$from = ' FROM ' . $table;
} else {
$from = ' FROM ' . $this->tableName( $table );
list( $startOpts, $useIndex, $preLimitTail, $postLimitTail ) = $this->makeSelectOptions( $options );
- if( !empty( $conds ) ) {
+ if ( !empty( $conds ) ) {
if ( is_array( $conds ) ) {
$conds = $this->makeList( $conds, LIST_AND );
}
$sql = "SELECT $startOpts $vars $from $useIndex $preLimitTail";
}
- if (isset($options['LIMIT']))
- $sql = $this->limitResult($sql, $options['LIMIT'],
- isset($options['OFFSET']) ? $options['OFFSET'] : false);
+ if ( isset( $options['LIMIT'] ) )
+ $sql = $this->limitResult( $sql, $options['LIMIT'],
+ isset( $options['OFFSET'] ) ? $options['OFFSET'] : false );
$sql = "$sql $postLimitTail";
- if (isset($options['EXPLAIN'])) {
+ if ( isset( $options['EXPLAIN'] ) ) {
$sql = 'EXPLAIN ' . $sql;
}
+
return $sql;
}
function selectRow( $table, $vars, $conds, $fname = 'DatabaseBase::selectRow', $options = array(), $join_conds = array() ) {
$options['LIMIT'] = 1;
$res = $this->select( $table, $vars, $conds, $fname, $options, $join_conds );
- if ( $res === false )
+
+ if ( $res === false ) {
return false;
- if ( !$this->numRows($res) ) {
+ }
+
+ if ( !$this->numRows( $res ) ) {
return false;
}
+
$obj = $this->fetchObject( $res );
+
return $obj;
}
* @param $options Array: options for select
* @return Integer: row count
*/
- public function estimateRowCount( $table, $vars='*', $conds='', $fname = 'DatabaseBase::estimateRowCount', $options = array() ) {
+ public function estimateRowCount( $table, $vars = '*', $conds = '', $fname = 'DatabaseBase::estimateRowCount', $options = array() ) {
$rows = 0;
$res = $this->select ( $table, 'COUNT(*) AS rowcount', $conds, $fname, $options );
+
if ( $res ) {
$row = $this->fetchRow( $res );
$rows = ( isset( $row['rowcount'] ) ) ? $row['rowcount'] : 0;
}
+
return $rows;
}
# 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);
+ $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);
+ $sql = preg_replace ( '/\s+/', ' ', $sql );
# All numbers => N
- $sql = preg_replace ('/-?[0-9]+/s', 'N', $sql);
+ $sql = preg_replace ( '/-?[0-9]+/s', 'N', $sql );
return $sql;
}
*/
function fieldExists( $table, $field, $fname = 'DatabaseBase::fieldExists' ) {
$info = $this->fieldInfo( $table, $field );
+
return (bool)$info;
}
$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 = 'DatabaseBase::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 );
- $index = $this->indexName( $index );
- $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;
- }
+ } else {
+ return $info !== false;
}
-
- return empty($result) ? false : $result;
}
/**
function tableExists( $table ) {
$table = $this->tableName( $table );
$old = $this->ignoreErrors( true );
- $res = $this->query( "SELECT 1 FROM $table LIMIT 1" );
+ $res = $this->query( "SELECT 1 FROM $table LIMIT 1", __METHOD__ );
$this->ignoreErrors( $old );
+
return (bool)$res;
}
- /**
- * mysql_fetch_field() wrapper
- * Returns false if the field doesn't exist
- *
- * @param $table
- * @param $field
- */
- abstract function fieldInfo( $table, $field );
-
/**
* mysql_field_type() wrapper
*/
if ( $res instanceof ResultWrapper ) {
$res = $res->result;
}
+
return mysql_field_type( $res, $index );
}
*/
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
*
* @return bool
*/
function insert( $table, $a, $fname = 'DatabaseBase::insert', $options = array() ) {
- return this->insertOnDupeUpdate( $table, $a, $fname, $options );
- }
-
- /**
- * INSERT ... ON DUPE UPDATE wrapper, inserts an array into a table, optionally updating if
- * duplicate primary key found
- *
- * $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
- *
- * @param $table String: table name (prefix auto-added)
- * @param $a Array: Array of rows to insert
- * @param $fname String: Calling function name (use __METHOD__) for logs/profiling
- * @param $options Mixed: Associative array of options
- * @param $onDupeUpdate Array: Associative array of fields to update on duplicate
- *
- * @return bool
- */
- function insertOnDupeUpdate( $table, $a, $fname = 'DatabaseBase::insertOnDupeUpdate', $options = array(), $onDupeUpdate = 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 {
$sql .= '(' . $this->makeList( $a ) . ')';
}
-
- if ( count( $onDupeUpdate ) ) {
- $sql .= ' ON DUPLICATE KEY UPDATE ' . $this->makeList( $onDupeUpdate );
- }
-
+
return (bool)$this->query( $sql, $fname );
}
* @return string
*/
function makeUpdateOptions( $options ) {
- if( !is_array( $options ) ) {
+ if ( !is_array( $options ) ) {
$options = array( $options );
}
+
$opts = array();
- if ( in_array( 'LOW_PRIORITY', $options ) )
+
+ if ( in_array( 'LOW_PRIORITY', $options ) ) {
$opts[] = $this->lowPriorityOption();
- if ( in_array( 'IGNORE', $options ) )
+ }
+
+ if ( in_array( 'IGNORE', $options ) ) {
$opts[] = 'IGNORE';
- return implode(' ', $opts);
+ }
+
+ return implode( ' ', $opts );
}
/**
$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 );
}
$first = true;
$list = '';
+
foreach ( $a as $field => $value ) {
if ( !$first ) {
if ( $mode == LIST_AND ) {
$list .= ' AND ';
- } elseif($mode == LIST_OR) {
+ } elseif ( $mode == LIST_OR ) {
$list .= ' OR ';
} else {
$list .= ',';
} else {
$first = false;
}
- if ( ($mode == LIST_AND || $mode == LIST_OR) && is_numeric( $field ) ) {
+
+ if ( ( $mode == LIST_AND || $mode == LIST_OR ) && is_numeric( $field ) ) {
$list .= "($value)";
- } elseif ( ($mode == LIST_SET) && is_numeric( $field ) ) {
+ } 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 ) {
+ } 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] );
+ $list .= $field . " = " . $this->addQuotes( $value[0] );
} else {
- $list .= $field." IN (".$this->makeList($value).") ";
+ $list .= $field . " IN (" . $this->makeList( $value ) . ") ";
}
- } elseif( $value === null ) {
+ } elseif ( $value === null ) {
if ( $mode == LIST_AND || $mode == LIST_OR ) {
$list .= "$field IS ";
} elseif ( $mode == LIST_SET ) {
$list .= $mode == LIST_NAMES ? $value : $this->addQuotes( $value );
}
}
+
return $list;
}
*/
function makeWhereFrom2d( $data, $baseKey, $subKey ) {
$conds = array();
+
foreach ( $data as $base => $sub ) {
if ( count( $sub ) ) {
$conds[] = $this->makeList(
array( $baseKey => $base, $subKey => array_keys( $sub ) ),
- LIST_AND);
+ LIST_AND );
}
}
* Bitwise operations
*/
- function bitNot($field) {
+ function bitNot( $field ) {
return "(~$field)";
}
- function bitAnd($fieldLeft, $fieldRight) {
+ function bitAnd( $fieldLeft, $fieldRight ) {
return "($fieldLeft & $fieldRight)";
}
- function bitOr($fieldLeft, $fieldRight) {
+ function bitOr( $fieldLeft, $fieldRight ) {
return "($fieldLeft | $fieldRight)";
}
/**
* Change the current database
*
+ * @todo Explain what exactly will fail if this is not overridden.
* @return bool Success or failure
*/
function selectDB( $db ) {
# Stub. Shouldn't cause serious problems if it's not overridden, but
# if your database engine supports a concept similar to MySQL's
- # databases you may as well. TODO: explain what exactly will fail if
- # this is not overridden.
+ # databases you may as well.
return true;
}
# 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;
+ 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
# 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;
+ 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;
+ 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}`" );
+ 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.
+ 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 )
}
# Quote the $database and $table and apply the prefix if not quoted.
- if( isset($database) ) $database = ( $database[0] == '`' ? $database : "`{$database}`" );
+ 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}" );
+ $tableName = ( isset( $database ) ? "{$database}.{$table}" : "{$table}" );
- # We're finished, return.
return $tableName;
}
public function tableNames() {
$inArray = func_get_args();
$retVal = array();
+
foreach ( $inArray as $name ) {
$retVal[$name] = $this->tableName( $name );
}
+
return $retVal;
}
public function tableNamesN() {
$inArray = func_get_args();
$retVal = array();
+
foreach ( $inArray as $name ) {
$retVal[] = $this->tableName( $name );
}
+
return $retVal;
}
+ /**
+ * Get an aliased table name
+ * e.g. tableName AS newTableName
+ *
+ * @param $name string Table name, see tableName()
+ * @param $alias string Alias (optional)
+ * @return string SQL name for aliased table. Will not alias a table to its own name
+ */
+ public function tableNameWithAlias( $name, $alias = false ) {
+ if ( !$alias || $alias == $name ) {
+ return $this->tableName( $name );
+ } else {
+ return $this->tableName( $name ) . ' `' . $alias . '`';
+ }
+ }
+
+ /**
+ * Gets an array of aliased table names
+ *
+ * @param $tables array( [alias] => table )
+ * @return array of strings, see tableNameWithAlias()
+ */
+ public function tableNamesWithAlias( $tables ) {
+ $retval = array();
+ foreach ( $tables as $alias => $table ) {
+ if ( is_numeric( $alias ) ) {
+ $alias = $table;
+ }
+ $retval[] = $this->tableNameWithAlias( $table, $alias );
+ }
+ 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 ) {
+ $use_index_safe = is_array( $use_index ) ? $use_index : array();
+ $join_conds_safe = is_array( $join_conds ) ? $join_conds : array();
+
+ foreach ( $tables as $alias => $table ) {
+ if ( !is_string( $alias ) ) {
+ // No alias? Set it equal to the table name
+ $alias = $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] ) );
- $on = $this->makeList((array)$join_conds_safe[$table][1], LIST_AND);
+ if ( isset( $join_conds_safe[$alias] ) && isset( $use_index_safe[$alias] ) ) {
+ $tableClause = $join_conds_safe[$alias][0] . ' ' . $this->tableNameWithAlias( $table, $alias );
+ $tableClause .= ' ' . $this->useIndexClause( implode( ',', (array)$use_index_safe[$alias] ) );
+ $on = $this->makeList( (array)$join_conds_safe[$alias][1], LIST_AND );
if ( $on != '' ) {
$tableClause .= ' ON (' . $on . ')';
}
+
$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] ) );
+ } else if ( isset( $use_index_safe[$alias] ) ) {
+ $tableClause = $this->tableNameWithAlias( $table, $alias );
+ $tableClause .= ' ' . $this->useIndexClause( implode( ',', (array)$use_index_safe[$alias] ) );
$ret[] = $tableClause;
// Is there a JOIN clause?
- } else if ( isset($join_conds_safe[$table]) ) {
- $tableClause = $join_conds_safe[$table][0] . ' ' . $this->tableName( $table );
- $on = $this->makeList((array)$join_conds_safe[$table][1], LIST_AND);
+ } else if ( isset( $join_conds_safe[$alias] ) ) {
+ $tableClause = $join_conds_safe[$alias][0] . ' ' . $this->tableNameWithAlias( $table, $alias );
+ $on = $this->makeList( (array)$join_conds_safe[$alias][1], LIST_AND );
if ( $on != '' ) {
$tableClause .= ' ON (' . $on . ')';
- }
+ }
+
$retJOIN[] = $tableClause;
} else {
- $tableClause = $this->tableName( $table );
+ $tableClause = $this->tableNameWithAlias( $table, $alias );
$ret[] = $tableClause;
}
}
+
// We can't separate explicit JOIN clauses with ',', use ' ' for those
- $straightJoins = !empty($ret) ? implode( ',', $ret ) : "";
- $otherJoins = !empty($retJOIN) ? implode( ' ', $retJOIN ) : "";
+ $straightJoins = !empty( $ret ) ? implode( ',', $ret ) : "";
+ $otherJoins = !empty( $retJOIN ) ? implode( ' ', $retJOIN ) : "";
+
// Compile our final table clause
- return implode(' ',array($straightJoins,$otherJoins) );
+ return implode( ' ', array( $straightJoins, $otherJoins ) );
}
/**
'un_user_id' => 'user_id',
'un_user_ip' => 'user_ip',
);
- if( isset( $renamed[$index] ) ) {
+
+ if ( isset( $renamed[$index] ) ) {
return $renamed[$index];
} else {
return $index;
}
}
- /**
- * Wrapper for addslashes()
- * @param $s String: to be slashed.
- * @return String: slashed string.
- */
- abstract function strencode( $s );
-
/**
* If it's a string, adds quotes and backslashes
* Otherwise returns as-is
}
}
+ /**
+ * Quotes an identifier using `backticks` or "double quotes" depending on the database type.
+ * MySQL uses `backticks` while basically everything else uses double quotes.
+ * Since MySQL is the odd one out here the double quotes are our generic
+ * and we implement backticks in DatabaseMysql.
+ */
+ public function addIdentifierQuotes( $s ) {
+ return '"' . str_replace( '"', '""', $s ) . '"';
+ }
+
+ /**
+ * Backwards compatibility, identifier quoting originated in DatabasePostgres
+ * which used quote_ident which does not follow our naming conventions
+ * was renamed to addIdentifierQuotes.
+ * @deprecated use addIdentifierQuotes
+ */
+ function quote_ident( $s ) {
+ wfDeprecated( __METHOD__ );
+ return $this->addIdentifierQuotes( $s );
+ }
+
/**
* Escape string for safe LIKE usage.
* WARNING: you should almost never use this function directly,
$s = str_replace( '\\', '\\\\', $s );
$s = $this->strencode( $s );
$s = str_replace( array( '%', '_' ), array( '\%', '\_' ), $s );
+
return $s;
}
*/
function buildLike() {
$params = func_get_args();
- if (count($params) > 0 && is_array($params[0])) {
+
+ if ( count( $params ) > 0 && is_array( $params[0] ) ) {
$params = $params[0];
}
$s = '';
- foreach( $params as $value) {
- if( $value instanceof LikeMatch ) {
+
+ foreach ( $params as $value ) {
+ if ( $value instanceof LikeMatch ) {
$s .= $value->toString();
} else {
$s .= $this->escapeLikeInternal( $value );
}
}
+
return " LIKE '" . $s . "' ";
}
* 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
+ * @param $table String: The table to replace the row(s) in.
+ * @param $uniqueIndexes Array: An associative array of indexes
+ * @param $rows Array: Array of rows to replace
+ * @param $fname String: Calling function name (use __METHOD__) for logs/profiling
*/
function replace( $table, $uniqueIndexes, $rows, $fname = 'DatabaseBase::replace' ) {
$table = $this->tableName( $table );
$rows = array( $rows );
}
- $sql = "REPLACE INTO $table (" . implode( ',', array_keys( $rows[0] ) ) .') VALUES ';
+ $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 );
}
$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 );
}
$row = $this->fetchObject( $res );
$m = array();
+
if ( preg_match( '/\((.*)\)/', $row->Type, $m ) ) {
$size = $m[1];
} else {
$size = -1;
}
+
return $size;
}
if ( !$conds ) {
throw new DBUnexpectedError( $this, 'DatabaseBase::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 );
}
$insertOptions = array(), $selectOptions = array() )
{
$destTable = $this->tableName( $destTable );
+
if ( is_array( $insertOptions ) ) {
$insertOptions = implode( ' ', $insertOptions );
}
- if( !is_array( $selectOptions ) ) {
+
+ if ( !is_array( $selectOptions ) ) {
$selectOptions = array( $selectOptions );
}
+
list( $startOpts, $useIndex, $tailOpts ) = $this->makeSelectOptions( $selectOptions );
- if( is_array( $srcTable ) ) {
+
+ 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 );
}
* @param $limit Integer: the SQL limit
* @param $offset Integer the SQL offset (default false)
*/
- function limitResult( $sql, $limit, $offset=false ) {
- if( !is_numeric( $limit ) ) {
+ 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}," : "" )
+ . ( ( is_numeric( $offset ) && $offset != 0 ) ? "{$offset}," : "" )
. "{$limit} ";
}
+
function limitResultForUpdate( $sql, $num ) {
return $this->limitResult( $sql, $num, 0 );
}
* @param $all Boolean: use UNION ALL
* @return String: SQL fragment
*/
- function unionQueries($sqls, $all) {
+ function unionQueries( $sqls, $all ) {
$glue = $all ? ') UNION ALL (' : ') UNION (';
- return '('.implode( $glue, $sqls ) . ')';
+ return '(' . implode( $glue, $sqls ) . ')';
}
/**
$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();
$this->reportQueryError( $error, $errno, $sql, $fname );
}
}
- } while( $this->wasDeadlock() && --$tries > 0 );
+ } while ( $this->wasDeadlock() && --$tries > 0 );
+
$this->ignoreErrors( $oldIgnore );
+
if ( $tries <= 0 ) {
$this->rollback( $myFname );
$this->reportQueryError( $error, $errno, $sql, $fname );
}
if ( !is_null( $this->mFakeSlaveLag ) ) {
- $wait = intval( ( $pos->pos - microtime(true) + $this->mFakeSlaveLag ) * 1e6 );
+ $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 );
$encPos = intval( $pos->pos );
$sql = "SELECT MASTER_POS_WAIT($encFile, $encPos, $timeout)";
$res = $this->doQuery( $sql );
+
if ( $res && $row = $this->fetchRow( $res ) ) {
wfProfileOut( $fname );
return $row[0];
*/
function getSlavePos() {
if ( !is_null( $this->mFakeSlaveLag ) ) {
- $pos = new MySQLMasterPos( 'fake', microtime(true) - $this->mFakeSlaveLag );
- wfDebug( __METHOD__.": fake slave pos = $pos\n" );
+ $pos = new MySQLMasterPos( 'fake', microtime( true ) - $this->mFakeSlaveLag );
+ wfDebug( __METHOD__ . ": fake slave pos = $pos\n" );
return $pos;
}
+
$res = $this->query( 'SHOW SLAVE STATUS', 'DatabaseBase::getSlavePos' );
$row = $this->fetchObject( $res );
+
if ( $row ) {
- $pos = isset($row->Exec_master_log_pos) ? $row->Exec_master_log_pos : $row->Exec_Master_Log_Pos;
+ $pos = isset( $row->Exec_master_log_pos ) ? $row->Exec_master_log_pos : $row->Exec_Master_Log_Pos;
return new MySQLMasterPos( $row->Relay_Master_Log_File, $pos );
} else {
return false;
if ( $this->mFakeMaster ) {
return new MySQLMasterPos( 'fake', microtime( true ) );
}
+
$res = $this->query( 'SHOW MASTER STATUS', 'DatabaseBase::getMasterPos' );
$row = $this->fetchObject( $res );
+
if ( $row ) {
return new MySQLMasterPos( $row->File, $row->Position );
} else {
* End a transaction
*/
function commit( $fname = 'DatabaseBase::commit' ) {
- if( $this->mTrxLevel ) {
+ if ( $this->mTrxLevel ) {
$this->query( 'COMMIT', $fname );
$this->mTrxLevel = 0;
}
* No-op on non-transactional databases.
*/
function rollback( $fname = 'DatabaseBase::rollback' ) {
- if( $this->mTrxLevel ) {
+ if ( $this->mTrxLevel ) {
$this->query( 'ROLLBACK', $fname, true );
$this->mTrxLevel = 0;
}
function duplicateTableStructure( $oldName, $newName, $temporary = false, $fname = 'DatabaseBase::duplicateTableStructure' ) {
throw new MWException( 'DatabaseBase::duplicateTableStructure is not implemented in descendant class' );
}
+
+ /**
+ * List all tables on the database
+ *
+ * @param $prefix Only show tables with this prefix, e.g. mw_
+ * @param $fname String: calling function name
+ */
+ function listTables( $prefix = null, $fname = 'DatabaseBase::listTables' ) {
+ throw new MWException( 'DatabaseBase::listTables is not implemented in descendant class' );
+ }
/**
* Return MW-style timestamp used for MySQL schema
*/
- function timestamp( $ts=0 ) {
- return wfTimestamp(TS_MW,$ts);
+ function timestamp( $ts = 0 ) {
+ return wfTimestamp( TS_MW, $ts );
}
/**
* Local database timestamp format or null
*/
function timestampOrNull( $ts = null ) {
- if( is_null( $ts ) ) {
+ if ( is_null( $ts ) ) {
return null;
} else {
return $this->timestamp( $ts );
* @todo document
*/
function resultObject( $result ) {
- if( empty( $result ) ) {
+ if ( empty( $result ) ) {
return false;
} elseif ( $result instanceof ResultWrapper ) {
return $result;
/**
* Return aggregated value alias
*/
- function aggregateValue ($valuedata,$valuename='value') {
+ function aggregateValue ( $valuedata, $valuename = 'value' ) {
return $valuename;
}
- /**
- * Returns a wikitext link to the DB's website, e.g.,
- * return "[http://www.mysql.com/ MySQL]";
- * Should at least contain plain text, if for some reason
- * your database has no website.
- *
- * @return String: wikitext of a link to the server software's web site
- */
- public static function getSoftwareLink() {
- throw new MWException( "A child class of DatabaseBase didn't implement getSoftwareLink(), shame on them" );
- }
-
- /**
- * A string describing the current software version, like from
- * mysql_get_server_info(). Will be listed on Special:Version, etc.
- *
- * @return String: Version information from the database
- */
- abstract function getServerVersion();
-
/**
* Ping the server and try to reconnect if it there is no connection
*
* @return Database replication lag in seconds
*/
function getLag() {
- return $this->mFakeSlaveLag;
+ return intval( $this->mFakeSlaveLag );
}
/**
* Get status information from SHOW STATUS in an associative array
*/
- function getStatus($which="%") {
+ function getStatus( $which = "%" ) {
$res = $this->query( "SHOW STATUS LIKE '{$which}'" );
$status = array();
- while ( $row = $this->fetchObject( $res ) ) {
+
+ foreach ( $res as $row ) {
$status[$row->Variable_name] = $row->Value;
}
+
return $status;
}
return 0;
}
- function encodeBlob($b) {
+ function encodeBlob( $b ) {
return $b;
}
- function decodeBlob($b) {
+ function decodeBlob( $b ) {
return $b;
}
* @param $filename String: File name to open
* @param $lineCallback Callback: Optional function called before reading each line
* @param $resultCallback Callback: Optional function called for each MySQL result
+ * @param $fname String: Calling function name or false if name should be generated dynamically
+ * using $filename
*/
- function sourceFile( $filename, $lineCallback = false, $resultCallback = false ) {
+ function sourceFile( $filename, $lineCallback = false, $resultCallback = false, $fname = false ) {
+ wfSuppressWarnings();
$fp = fopen( $filename, 'r' );
+ wfRestoreWarnings();
+
if ( false === $fp ) {
- if (!defined("MEDIAWIKI_INSTALL"))
- throw new MWException( "Could not open \"{$filename}\".\n" );
- else
- return "Could not open \"{$filename}\".\n";
+ throw new MWException( "Could not open \"{$filename}\".\n" );
+ }
+
+ if ( !$fname ) {
+ $fname = __METHOD__ . "( $filename )";
}
+
try {
- $error = $this->sourceStream( $fp, $lineCallback, $resultCallback );
+ $error = $this->sourceStream( $fp, $lineCallback, $resultCallback, $fname );
}
- catch( MWException $e ) {
- if ( defined("MEDIAWIKI_INSTALL") ) {
- $error = $e->getMessage();
- } else {
- fclose( $fp );
- throw $e;
- }
+ catch ( MWException $e ) {
+ fclose( $fp );
+ throw $e;
}
-
+
fclose( $fp );
+
return $error;
}
* @param $patch String The name of the patch, like patch-something.sql
* @return String Full path to patch file
*/
- public static function patchPath( $patch ) {
- global $wgDBtype, $IP;
- if ( file_exists( "$IP/maintenance/$wgDBtype/archives/$patch" ) ) {
- return "$IP/maintenance/$wgDBtype/archives/$patch";
+ public function patchPath( $patch ) {
+ global $IP;
+
+ $dbType = $this->getType();
+ if ( file_exists( "$IP/maintenance/$dbType/archives/$patch" ) ) {
+ return "$IP/maintenance/$dbType/archives/$patch";
} else {
return "$IP/maintenance/archives/$patch";
}
* @param $fp String: File handle
* @param $lineCallback Callback: Optional function called before reading each line
* @param $resultCallback Callback: Optional function called for each MySQL result
+ * @param $fname String: Calling function name
*/
- function sourceStream( $fp, $lineCallback = false, $resultCallback = false ) {
+ function sourceStream( $fp, $lineCallback = false, $resultCallback = false, $fname = 'DatabaseBase::sourceStream' ) {
$cmd = "";
$done = false;
$dollarquote = false;
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; }
+ if ( $sl < 0 ) {
+ continue;
+ }
+
+ if ( '-' == $line { 0 } && '-' == $line { 1 } ) {
+ continue;
+ }
- ## Allow dollar quoting for function declarations
- if (substr($line,0,4) == '$mw$') {
- if ($dollarquote) {
+ # # Allow dollar quoting for function declarations
+ if ( substr( $line, 0, 4 ) == '$mw$' ) {
+ if ( $dollarquote ) {
$dollarquote = false;
$done = true;
}
$dollarquote = true;
}
}
- else if (!$dollarquote) {
- if ( ';' == $line{$sl} && ($sl < 2 || ';' != $line{$sl - 1})) {
+ else if ( !$dollarquote ) {
+ if ( ';' == $line { $sl } && ( $sl < 2 || ';' != $line { $sl - 1 } ) ) {
$done = true;
$line = substr( $line, 0, $sl );
}
}
- if ( $cmd != '' ) { $cmd .= ' '; }
+ if ( $cmd != '' ) {
+ $cmd .= ' ';
+ }
+
$cmd .= "$line\n";
if ( $done ) {
- $cmd = str_replace(';;', ";", $cmd);
+ $cmd = str_replace( ';;', ";", $cmd );
$cmd = $this->replaceVars( $cmd );
- $res = $this->query( $cmd, __METHOD__ );
+ $res = $this->query( $cmd, $fname );
+
if ( $resultCallback ) {
call_user_func( $resultCallback, $res, $this );
}
$done = false;
}
}
+
return true;
}
+ /**
+ * Database independent variable replacement, replaces a set of named variables
+ * in a sql statement with the contents of their global variables.
+ * Supports '{$var}' `{$var}` and / *$var* / (without the spaces) style variables
+ *
+ * '{$var}' should be used for text and is passed through the database's addQuotes method
+ * `{$var}` should be used for identifiers (eg: table and database names), it is passed through
+ * the database's addIdentifierQuotes method which can be overridden if the database
+ * uses something other than backticks.
+ * / *$var* / is just encoded, besides traditional dbprefix and tableoptions it's use should be avoided
+ *
+ * @param $ins String: SQL statement to replace variables in
+ * @param $varnames Array: Array of global variable names to replace
+ * @return String The new SQL statement with variables replaced
+ */
+ protected function replaceGlobalVars( $ins, $varnames ) {
+ foreach ( $varnames as $var ) {
+ if ( isset( $GLOBALS[$var] ) ) {
+ $ins = str_replace( '\'{$' . $var . '}\'', $this->addQuotes( $GLOBALS[$var] ), $ins ); // replace '{$var}'
+ $ins = str_replace( '`{$' . $var . '}`', $this->addIdentifierQuotes( $GLOBALS[$var] ), $ins ); // replace `{$var}`
+ $ins = str_replace( '/*$' . $var . '*/', $this->strencode( $GLOBALS[$var] ) , $ins ); // replace /*$var*/
+ }
+ }
+ return $ins;
+ }
/**
* Replace variables in sourced SQL
'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 );
- }
- }
+ $ins = $this->replaceGlobalVars( $ins, $varnames );
// Table prefixes
$ins = preg_replace_callback( '!/\*(?:\$wgDBprefix|_)\*/([a-zA-Z_0-9]*)!',
// Index names
$ins = preg_replace_callback( '!/\*i\*/([a-zA-Z_0-9]*)!',
array( $this, 'indexNameCallback' ), $ins );
+
return $ins;
}
return true;
}
+ /**
+ * Delete a table
+ */
+ public function dropTable( $tableName, $fName = 'DatabaseBase::dropTable' ) {
+ if( !$this->tableExists( $tableName ) ) {
+ return false;
+ }
+ $sql = "DROP TABLE " . $this->tableName( $tableName );
+ if( $this->cascadingDeletes() ) {
+ $sql .= " CASCADE";
+ }
+ return $this->query( $sql, $fName );
+ }
+
/**
* Get search engine class. All subclasses of this need to implement this
* if they wish to use searching.
return 'SearchEngineDummy';
}
+ /**
+ * Find out when 'infinity' is. Most DBMSes support this. This is a special
+ * keyword for timestamps in PostgreSQL, and works with CHAR(14) as well
+ * because "i" sorts after all numbers.
+ *
+ * @return String
+ */
+ public function getInfinity() {
+ return 'infinity';
+ }
+
/**
* Allow or deny "big selects" for this session only. This is done by setting
* the sql_big_selects session variable.
}
}
-
/******************************************************************************
* Utility classes
*****************************************************************************/
class DBObject {
public $mData;
- function DBObject($data) {
+ function __construct( $data ) {
$this->mData = $data;
}
*/
class Blob {
private $mData;
- function __construct($data) {
+
+ function __construct( $data ) {
$this->mData = $data;
}
+
function fetch() {
return $this->mData;
}
}
/**
- * Utility class.
+ * Base for all database-specific classes representing information about database fields
* @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;
- }
+interface Field {
+ /**
+ * Field name
+ * @return string
+ */
+ function name();
- function isKey() {
- return $this->is_key;
- }
+ /**
+ * Name of table this field belongs to
+ * @return string
+ */
+ function tableName();
- function isMultipleKey() {
- return $this->is_multiple;
- }
+ /**
+ * Database type
+ * @return string
+ */
+ function type();
- function type() {
- return $this->type;
- }
+ /**
+ * Whether this field can store NULL values
+ * @return bool
+ */
+ function isNullable();
}
/******************************************************************************
function getText() {
global $wgShowDBErrorBacktrace;
+
$s = $this->getMessage() . "\n";
+
if ( $wgShowDBErrorBacktrace ) {
$s .= "Backtrace:\n" . $this->getTraceAsString() . "\n";
}
+
return $s;
}
}
function __construct( DatabaseBase &$db, $error = 'unknown error' ) {
$msg = 'DB connection error';
+
if ( trim( $error ) != '' ) {
$msg .= ": $error";
}
+
$this->error = $error;
+
parent::__construct( $db, $msg );
}
function getPageTitle() {
global $wgSitename, $wgLang;
+
$header = "$wgSitename has a problem";
+
if ( $wgLang instanceof Language ) {
$header = htmlspecialchars( $wgLang->getMessage( 'dberr-header' ) );
}
}
if ( trim( $this->error ) == '' ) {
- $this->error = $this->db->getProperty('mServer');
+ $this->error = $this->db->getProperty( 'mServer' );
}
+ $this->error = Html::element( 'span', array( 'dir' => 'ltr' ), $this->error );
+
$noconnect = "<p><strong>$sorry</strong><br />$again</p><p><small>$info</small></p>";
$text = str_replace( '$1', $this->error, $noconnect );
$extra = $this->searchForm();
- if( $wgUseFileCache ) {
+ if ( $wgUseFileCache ) {
try {
$cache = $this->fileCachedPage();
# Cached version on file system?
- if( $cache !== null ) {
+ if ( $cache !== null ) {
# Hack: extend the body for error messages
- $cache = str_replace( array('</html>','</body>'), '', $cache );
+ $cache = str_replace( array( '</html>', '</body>' ), '', $cache );
# Add cache notice...
$cachederror = "This is a cached copy of the requested page, and may not be up to date. ";
+
# Localize it if possible...
- if( $wgLang instanceof Language ) {
+ if ( $wgLang instanceof Language ) {
$cachederror = htmlspecialchars( $wgLang->getMessage( 'dberr-cachederror' ) );
}
+
$warning = "<div style='color:red;font-size:150%;font-weight:bold;'>$cachederror</div>";
+
# Output cached page with notices on bottom and re-close body
return "{$cache}{$warning}<hr />$text<hr />$extra</body></html>";
}
- } catch( MWException $e ) {
+ } catch ( MWException $e ) {
// Do nothing, just use the default page
}
}
+
# Headers needed here - output is just the error message
- return $this->htmlHeader()."$text<hr />$extra".$this->htmlFooter();
+ return $this->htmlHeader() . "$text<hr />$extra" . $this->htmlFooter();
}
function searchForm() {
- global $wgSitename, $wgServer, $wgLang, $wgInputEncoding;
+ global $wgSitename, $wgServer, $wgLang;
+
$usegoogle = "You can try searching via Google in the meantime.";
$outofdate = "Note that their indexes of our content may be out of date.";
$googlesearch = "Search";
$googlesearch = htmlspecialchars( $wgLang->getMessage( 'searchbutton' ) );
}
- $search = htmlspecialchars(@$_REQUEST['search']);
+ $search = htmlspecialchars( @$_REQUEST['search'] );
+
+ $server = htmlspecialchars( $wgServer );
+ $sitename = htmlspecialchars( $wgSitename );
$trygoogle = <<<EOT
<div style="margin: 1.5em">$usegoogle<br />
<small>$outofdate</small></div>
<!-- SiteSearch Google -->
<form method="get" action="http://www.google.com/search" id="googlesearch">
- <input type="hidden" name="domains" value="$wgServer" />
- <input type="hidden" name="num" value="50" />
- <input type="hidden" name="ie" value="$wgInputEncoding" />
- <input type="hidden" name="oe" value="$wgInputEncoding" />
+ <input type="hidden" name="domains" value="$server" />
+ <input type="hidden" name="num" value="50" />
+ <input type="hidden" name="ie" value="UTF-8" />
+ <input type="hidden" name="oe" value="UTF-8" />
- <input type="text" name="q" size="31" maxlength="255" value="$search" />
- <input type="submit" name="btnG" value="$googlesearch" />
+ <input type="text" name="q" size="31" maxlength="255" value="$search" />
+ <input type="submit" name="btnG" value="$googlesearch" />
<div>
- <input type="radio" name="sitesearch" id="gwiki" value="$wgServer" checked="checked" /><label for="gwiki">$wgSitename</label>
- <input type="radio" name="sitesearch" id="gWWW" value="" /><label for="gWWW">WWW</label>
+ <input type="radio" name="sitesearch" id="gwiki" value="$server" checked="checked" /><label for="gwiki">$sitename</label>
+ <input type="radio" name="sitesearch" id="gWWW" value="" /><label for="gWWW">WWW</label>
</div>
</form>
<!-- SiteSearch Google -->
return $trygoogle;
}
- function fileCachedPage() {
- global $wgTitle, $title, $wgLang, $wgOut;
- if( $wgOut->isDisabled() ) return; // Done already?
+ private function fileCachedPage() {
+ global $wgTitle, $wgLang, $wgOut;
+
+ if ( $wgOut->isDisabled() ) {
+ return; // Done already?
+ }
+
$mainpage = 'Main Page';
+
if ( $wgLang instanceof Language ) {
- $mainpage = htmlspecialchars( $wgLang->getMessage( 'mainpage' ) );
+ $mainpage = htmlspecialchars( $wgLang->getMessage( 'mainpage' ) );
}
- if( $wgTitle ) {
+ if ( $wgTitle ) {
$t =& $wgTitle;
- } elseif( $title ) {
- $t = Title::newFromURL( $title );
} else {
$t = Title::newFromText( $mainpage );
}
$cache = new HTMLFileCache( $t );
- if( $cache->isFileCached() ) {
+ if ( $cache->isFileCached() ) {
return $cache->fetchPageText();
} else {
return '';
function htmlBodyOnly() {
return true;
}
-
}
/**
public $error, $errno, $sql, $fname;
function __construct( DatabaseBase &$db, $error, $errno, $sql, $fname ) {
- $message = "A database error has occurred\n" .
+ $message = "A database error has occurred. Did you forget to run maintenance/update.php after upgrading? See: http://www.mediawiki.org/wiki/Manual:Upgrading#Run_the_update_script\n" .
"Query: $sql\n" .
"Function: $fname\n" .
"Error: $errno $error\n";
parent::__construct( $db, $message );
+
$this->error = $error;
$this->errno = $errno;
$this->sql = $sql;
function getText() {
global $wgShowDBErrorBacktrace;
+
if ( $this->useMessageCache() ) {
$s = wfMsg( 'dberrortextcl', htmlspecialchars( $this->getSQL() ),
htmlspecialchars( $this->fname ), $this->errno, htmlspecialchars( $this->error ) ) . "\n";
+
if ( $wgShowDBErrorBacktrace ) {
$s .= "Backtrace:\n" . $this->getTraceAsString() . "\n";
}
+
return $s;
} else {
return parent::getText();
function getSQL() {
global $wgShowSQLErrors;
- if( !$wgShowSQLErrors ) {
+
+ if ( !$wgShowSQLErrors ) {
return $this->msg( 'sqlhidden', 'SQL hidden' );
} else {
return $this->sql;
function getHTML() {
global $wgShowDBErrorBacktrace;
+
if ( $this->useMessageCache() ) {
$s = wfMsgNoDB( 'dberrortext', htmlspecialchars( $this->getSQL() ),
htmlspecialchars( $this->fname ), $this->errno, htmlspecialchars( $this->error ) );
} else {
$s = nl2br( htmlspecialchars( $this->getMessage() ) );
}
+
if ( $wgShowDBErrorBacktrace ) {
$s .= '<p>Backtrace:</p><p>' . nl2br( htmlspecialchars( $this->getTraceAsString() ) );
}
+
return $s;
}
}
/**
* Create a new result object from a result resource and a Database object
*/
- function ResultWrapper( $database, $result ) {
+ function __construct( $database, $result ) {
$this->db = $database;
+
if ( $result instanceof ResultWrapper ) {
$this->result = $result->result;
} else {
*/
function rewind() {
- if ($this->numRows()) {
- $this->db->dataSeek($this, 0);
+ if ( $this->numRows() ) {
+ $this->db->dataSeek( $this, 0 );
}
$this->pos = 0;
$this->currentRow = null;
}
}
-/* Overloads the relevant methods of the real ResultsWrapper so it
+/**
+ * Overloads the relevant methods of the real ResultsWrapper so it
* doesn't go anywhere near an actual database.
*/
class FakeResultWrapper extends ResultWrapper {
-
var $result = array();
var $db = null; // And it's going to stay that way :D
var $pos = 0;
var $currentRow = null;
- function __construct( $array ){
+ function __construct( $array ) {
$this->result = $array;
}
function free() {}
// Callers want to be able to access fields with $this->fieldName
- function fetchObject(){
+ function fetchObject() {
$this->currentRow = $this->result[$this->pos++];
return (object)$this->currentRow;
}
dépôts / lhc / web / wiklou.git / blobdiff