View source for Manual:Database access

<languages/>
{{TOCRight}}
<translate>
<!--T:1-->
This article provides an overview of '''database access''' and general database issues in MediaWiki.

<!--T:78-->
When coding in MediaWiki, you will normally access the database only through MediaWiki's functions for the purpose.

==Database layout== <!--T:2-->
</translate>
<translate><!--T:3--> For information about the MediaWiki database layout, such as a description of the tables and their contents, please see <tvar name=layout>{{ll|Manual:Database layout}}</tvar>.</translate>
<translate><!--T:163--> Historically in MediaWiki, this was also documented in <tvar name=1><code>{{git file|branch=REL1_34|file=maintenance/tables.sql}}</code></tvar>, however, starting in MediaWiki 1.35, this was gradually moved into <tvar name=2><code>{{git file|file=sql/tables.json}}</code></tvar> as part of the Abstract Schema initiative.</translate>
<translate><!--T:164--> This means the <tvar name=1><code>{{git file|file=sql/tables.json}}</code></tvar> is turned into platform-specific files such as <tvar name=2><code>{{git file|file=sql/mysql/tables-generated.sql}}</code></tvar> by a <tvar name=3>{{ll|Manual:generateSchemaSql.php|maintenance script}}</tvar>, making it easier to generate schema files to support different database engines.</translate>

<translate>
==Logging into MySQL== <!--T:4-->

===Using <tvar name=1>sql.php</tvar>=== <!--T:142-->

<!--T:143-->
MediaWiki provides a maintenance script to access the database. From the <tvar name=1>maintenance</tvar> directory run:
</translate>

<syntaxhighlight lang="bash">
php run.php sql
</syntaxhighlight>

<translate><!--T:141--> You can then write out database queries. Alternatively you can provide a filename, and MediaWiki will execute it, substituting any MW special variables as appropriate.</translate>
<translate><!--T:144--> For more information, see <tvar name=man>{{ll|Manual:Sql.php}}</tvar>.</translate>

<translate>
<!--T:145-->
This will work for all database backends. However, the prompt is not as full features as the command line clients that come with your database.

===Using the mysql command line client=== <!--T:146-->
</translate>

<syntaxhighlight lang="php" style="overflow:auto;">
## <translate nowrap><!--T:79--> Database settings</translate>
$wgDBtype           = "mysql";
$wgDBserver         = "localhost";
$wgDBname           = "your-database-name";
$wgDBuser           = "your-database-username";  // Default: root
$wgDBpassword       = "your-password";
</syntaxhighlight>

<translate>
<!--T:5-->
In <tvar name=1><code>LocalSettings.php</code></tvar> you’ll find your wiki’s MySQL password and username, for example:

<!--T:7-->
With SSH, login by entering the following:
</translate>

<syntaxhighlight lang="bash" style="overflow:auto;">
mysql -u $wgDBuser -p --database=$wgDBname
</syntaxhighlight>

<translate><!--T:9--> Replacing <tvar name=1>{{phpi|$wgDBuser}}</tvar> and <tvar name=2>{{phpi|$wgDBname}}</tvar> with their <tvar name=3><code>LocalSettings.php</code></tvar> values.</translate>
<translate><!--T:178--> You will then be prompted for your password <tvar name=1>{{phpi|$wgDBpassword}}</tvar> after which you will see the <tvar name=2><code>mysql></code></tvar> prompt.</translate>

<translate>
==Database Abstraction Layer== <!--T:10-->

<!--T:11-->
MediaWiki uses the <tvar name=2>{{ll|Rdbms}}</tvar> library as its database abstraction layer. Developers must not directly call low-level database functions, such as <tvar name=1><code>mysql_query</code></tvar>.
</translate>

<translate><!--T:147--> Each connection is represented by  <tvar name=1><code>Wikimedia\Rdbms\IDatabase</code></tvar> from which queries can be performed.</translate>
<translate><!--T:148--> Connections can be acquired by calling <tvar name=4><code>getPrimaryDatabase()</code></tvar> or <tvar name=5><code>getReplicaDatabase()</code></tvar> (depending on the usecase) on an <tvar name=3><code>IConnectionProvider</code></tvar> instance, preferably dependency-injected, or obtained from <tvar name=1>MediaWikiServices</tvar> via <tvar name=6>DBLoadBalancerFactory</tvar> service.</translate>
<translate><!--T:149--> The function <tvar name=1><code>wfGetDB()</code></tvar> is being phased out and should not be used in new code.</translate>

<translate><!--T:13--> For getting database connections you can call either <tvar name="3"><code>getReplicaDatabase()</code></tvar> for read queries or <tvar name="4"><code>getPrimaryDatabase()</code></tvar> for write queries and write-informing read queries. The distinction between primary and replica is important in a multi-database environment, such as Wikimedia. See the [[<tvar name="1">#Wrapper_functions</tvar>|Wrapper functions]] section below for how to interact with <tvar name="2"><code>IDatabase</code></tvar> objects.</translate>

<translate>
<!--T:14-->
Read query example:
</translate>

{{MW 1.42|and later}}
<blockquote><syntaxhighlight lang="php" style="overflow:auto;">
use MediaWiki\MediaWikiServices;

$dbProvider = MediaWikiServices::getInstance()->getConnectionProvider();
$dbr = $dbProvider->getReplicaDatabase();

$res = $dbr->newSelectQueryBuilder()
  ->select( /* ... */ ) // see docs
  ->fetchResultSet();

foreach ( $res as $row ) {
	print $row->foo;
}
</syntaxhighlight></blockquote>

<translate>
<!--T:16-->
Write query example:
</translate>
{{MW 1.41|and later}}
<blockquote><syntaxhighlight lang="php" style="overflow:auto;">
$dbw = $dbProvider->getPrimaryDatabase();
$dbw->newInsertQueryBuilder()
    ->insertInto( /* ... */ ) // see docs
    ->caller( __METHOD__ )->execute();
</syntaxhighlight></blockquote>

<translate><!--T:18--> We use the convention <tvar name=1>{{phpi|$dbr}}</tvar> for readable connections (replica) and <tvar name=2>{{phpi|$dbw}}</tvar> for writable connections (primary). Also <tvar name=3>{{phpi|$dbProvider}}</tvar> is used for the IConnectionProvider instance</translate>

===SelectQueryBuilder===
{{MW 1.35|and later}}
<translate><!--T:180--> The <tvar name="1">{{class|SelectQueryBuilder}}</tvar> class is the preferred way to formulate read queries in new code.</translate> 
<translate><!--T:181--> In older code, you might find <tvar name="1"><code>select()</code></tvar> and related methods of the Database class used directly.</translate> 
<translate><!--T:182--> The query builder provides a modern "fluent" interface, where methods are chained until the fetch method is invoked, without intermediary variable assignments needed.</translate> 
<translate><!--T:183--> For example:</translate>

<syntaxhighlight lang="php">
$dbr = $dbProvider->getReplicaDatabase();
$res = $dbr->newSelectQueryBuilder()
	->select( [ 'cat_title', 'cat_pages' ] )
	->from( 'category' )
	->where( 'cat_pages > 0' )
	->orderBy( 'cat_title', SelectQueryBuilder::SORT_ASC )
	->caller( __METHOD__ )->fetchResultSet();
</syntaxhighlight>

As described below, MW 1.42 introduces a helper method, <code>expr()</code>, which lets you wrap the field, operator and value as an expression. Using this, the where clause in the above example can be rewitten as
<syntaxhighlight lang="php">
->where( $dbr->expr( 'cat_pages', '>', 0 ) )
</syntaxhighlight>

<translate><!--T:167--> This example corresponds to the following SQL:</translate>

<syntaxhighlight lang="sql">
SELECT cat_title, cat_pages FROM category WHERE cat_pages > 0 ORDER BY cat_title ASC
</syntaxhighlight>

<translate><!--T:168--> [[w:JOIN (SQL)|JOINs]] are also possible; for example:</translate>

<syntaxhighlight lang="php">
$dbr = $dbProvider->getReplicaDatabase();
$res = $dbr->newSelectQueryBuilder()
	->select( 'wl_user' )
	->from( 'watchlist' )
	->join( 'user_properties', /* alias: */ null, 'wl_user=up_user' )
	->where( [
		'wl_user != 1',
		'wl_namespace' => '0',
		'wl_title' => 'Main_page',
		'up_property' => 'enotifwatchlistpages',
	] )
	->caller( __METHOD__ )->fetchResultSet();
</syntaxhighlight>

<translate><!--T:169--> This example corresponds to the query:</translate>

<syntaxhighlight lang="sql">
SELECT wl_user
FROM `watchlist`
INNER JOIN `user_properties` ON ((wl_user=up_user))
WHERE (wl_user != 1)
AND wl_namespace = '0'
AND wl_title = 'Main_page'
AND up_property = 'enotifwatchlistpages'
</syntaxhighlight>

<translate><!--T:170--> You can access individual rows of the result using a foreach loop.</translate>
<translate><!--T:184--> Each row is represented as an object.</translate>
<translate><!--T:171--> For example:</translate>

<syntaxhighlight lang="php">
$dbr = $dbProvider->getReplicaDatabase();
$res = $dbr->newSelectQueryBuilder()
	->select( [ 'cat_title', 'cat_pages' ] )
	->from( 'category' )
	->where( 'cat_pages > 0' )
	->orderBy( 'cat_title', SelectQueryBuilder::SORT_ASC )
	->caller( __METHOD__ )->fetchResultSet();      

foreach ( $res as $row ) {
	print 'Category ' . $row->cat_title . ' contains ' . $row->cat_pages . " entries.\n";
}
</syntaxhighlight>

<translate><!--T:172--> There are also convenience functions to fetch a single row, a single field from several rows, or a single field from a single row:</translate>

<syntaxhighlight lang="php">
// Equivalent of:
//     $rows = fetchResultSet();
//     $row = $rows[0];
$pageRow = $dbr->newSelectQueryBuilder()
	->select( [ 'page_id', 'page_namespace', 'page_title' ] )
	->from( 'page' )
	->orderBy( 'page_touched', SelectQueryBuilder::SORT_DESC )
	->caller( __METHOD__ )->fetchRow();

// Equivalent of:
//     $rows = fetchResultSet();
//     $ids = array_map( fn( $row ) => $row->page_id, $rows );
$pageIds = $dbr->newSelectQueryBuilder()
	->select( 'page_id' )
	->from( 'page' )
	->where( [
		'page_namespace' => 1,
	] )
	->caller( __METHOD__ )->fetchFieldValues();

// Equivalent of:
//     $rows = fetchResultSet();
//     $id = $row[0]->page_id;
$pageId = $dbr->newSelectQueryBuilder()
	->select( 'page_id' )
	->from( 'page' )
	->where( [
		'page_namespace' => 1,
		'page_title' => 'Main_page',
	] )
	->caller( __METHOD__ )->fetchField();
</syntaxhighlight>

<translate>
<!--T:185-->
In these examples, <tvar name="1">{{phpi|$pageRow}}</tvar> is an row object as in the <tvar name="2">{{phpi|foreach}}</tvar> example above, <tvar name="3">{{phpi|$pageIds}}</tvar> is an array of page IDs, and <tvar name="4">{{phpi|$pageId}}</tvar> is a single page ID.
</translate>

While you can use <code>tables()</code> to add multiple tables, it is highly recommended to use <code>join()</code> or <code>leftJoin()</code> instead. Any aliases for additional tables must be added to <code>join()</code> or <code>leftJoin()</code>, not in <code>tables()</code>.

=== UpdateQueryBuilder ===
{{MW 1.41|and after}}
<translate><!--T:187--> SQL <tvar name=1>{{sqli|UPDATE}}</tvar> statements should be done with the <tvar name=2>{{ll|Manual:UpdateQueryBuilder.php|UpdateQueryBuilder}}</tvar>.</translate><syntaxhighlight lang="php">
$dbw = $this->dbProvider->getPrimaryDatabase();
$dbw->newUpdateQueryBuilder()
	->update( 'user' )
	->set( [ 'user_password' => $newHash->toString() ] )
	->where( [
		'user_id' => $oldRow->user_id,
		'user_password' => $oldRow->user_password,
	] )
	->caller( $fname )->execute();
</syntaxhighlight>

=== InsertQueryBuilder ===
{{MW 1.41|and after}}
<translate><!--T:188--> SQL <tvar name=1>{{sqli|INSERT}}</tvar> statements should be done with the InsertQueryBuilder.</translate><syntaxhighlight lang="php">
$dbw = $this->dbProvider->getPrimaryDatabase();
$targetRow = [
	'bt_address' => $targetAddress,
	'bt_user' => $targetUserId,
	/* etc */
];
$dbw->newInsertQueryBuilder()
	->insertInto( 'block_target' )
	->row( $targetRow )
	->caller( __METHOD__ )->execute();
$id = $dbw->insertId();
</syntaxhighlight>

=== DeleteQueryBuilder ===
{{MW 1.41|and after}}
<translate><!--T:189--> SQL <tvar name=1>{{sqli|DELETE}}</tvar> statements should be done with the DeleteQueryBuilder.</translate><syntaxhighlight lang="php">
$dbw = $this->dbProvider->getPrimaryDatabase();
$dbw->newDeleteQueryBuilder()
	->deleteFrom( 'block' )
	->where( [ 'bl_id' => $ids ] )
	->caller( __METHOD__ )->execute();
$numDeleted = $dbw->affectedRows();
</syntaxhighlight>

=== ReplaceQueryBuilder ===
{{MW 1.41|and after}}
<translate><!--T:190--> SQL <tvar name=1>{{sqli|REPLACE}}</tvar> statements should be done with the ReplaceQueryBuilder.</translate><syntaxhighlight lang="php">
$dbw = $this->dbProvider->getPrimaryDatabase();
$dbw->newReplaceQueryBuilder()
	->replaceInto( 'querycache_info' )
	->row( [
		'qci_type' => 'activeusers',
		'qci_timestamp' => $dbw->timestamp( $asOfTimestamp ),
	] )
	->uniqueIndexFields( [ 'qci_type' ] )
	->caller( __METHOD__ )->execute();
</syntaxhighlight>

=== UnionQueryBuilder ===
{{MW 1.41|and after}}
<translate><!--T:191--> SQL <tvar name=1>{{sqli|UNION}}</tvar> statements should be done with the UnionQueryBuilder.</translate><syntaxhighlight lang="php">
$dbr = $this->dbProvider->getReplicaDatabase();
$ids = $dbr->newUnionQueryBuilder()
	->add( $db->newSelectQueryBuilder()
		->select( 'bt_id' )
		->from( 'block_target' )
		->where( [ 'bt_address' => $addresses ] )
	)
	->add( $db->newSelectQueryBuilder()
		->select( 'bt_id' )
		->from( 'block_target' )
		->join( 'user', null, 'user_id=bt_user' )
		->where( [ 'user_name' => $userNames ] )
	)
	->caller( __METHOD__ )
	->fetchFieldValues();
</syntaxhighlight>

=== Batch queries ===
If you need to insert or update multiple rows, try to group them together into a batch query for increased efficiency. It's important to keep the table declaration (e.g. <code>update()</code>, <code>insertInto()</code>, etc.), <code>caller()</code>, and <code>execute()</code> outside the loop. Anything related to creating or updating rows can go inside the loop (e.g. <code>row()</code>).<syntaxhighlight lang="php">
$queryBuilder = $this->getDb()->newInsertQueryBuilder()
	->insertInto( 'ores_classification' )
	->caller( __METHOD__ );
foreach ( [ 0, 1, 2, 3 ] as $id ) {
	$predicted = $classId === $id;
	$queryBuilder->row( [
		'oresc_model' => $this->ensureOresModel( 'draftquality' ),
		'oresc_class' => $id,
    	'oresc_probability' => $predicted ? 0.7 : 0.1,
		'oresc_is_predicted' => $predicted ? 1 : 0,
		'oresc_rev' => $revId,
	] );
}
$queryBuilder->execute();
</syntaxhighlight>

<translate>
=== Helpers === <!--T:192-->

<!--T:193-->
The following helper methods should be used when appropriate, because they build SQL queries that are compatible with all supported database types, and they assist with auto escaping.
</translate>

==== <code>$dbr->expr()</code> ====
{{MW 1.42|and after}}
Should be used in WHERE statements whenever anything is being compared that isn't a simple equals statement. For example, <code>$dbr->expr( 'ptrp_page_id', '>', $start )</code>.

This method can be chained with <code>->and()</code> and <code>->or()</code>. For example, <code>$db->expr( 'ptrp_page_id', '=', null )->or( 'ptrpt_page_id', '=', null )</code>

==== <code>$dbr->timestamp()</code> ====
Different database engines format MediaWiki timestamps differently. Use this to ensure compatibility. Example: <code>$dbr->expr( 'ptrp_reviewed_updated', '>', $dbr->timestamp( $time ) )</code>

==== RawSQLExpression ====
{{MW 1.42|and after}}

Should be used in WHERE statements when you do not want to SQL escape anything. If comparing a field to a user value (much more common), use <code>$dbr->expr()</code> instead. RawSQLExpression does not escape, so it should never be used with user input. Use sparingly! Example: <code>$dbr->expr( new RawSQLExpression( 'rc_timestamp < fp_pending_since' ) )</code>

==== RawSQLValue ====
{{MW 1.43|and after}}
Should be used in WHERE statements when you do not want to SQL escape anything. If comparing a field to a user value (much more common), use <code>$dbr->expr()</code> instead. RawSQLValue does not escape, so it should never be used with user input. Use sparingly! Example: <code>$dbr->expr( 'fp_pending_since', '>', new RawSQLValue( $fieldName ) )</code>

<translate>
===Wrapper functions and raw queries=== <!--T:19-->
</translate>
Older MediaWiki code may use wrapper functions like <code>$dbr->select()</code> and <code>$dbw->insert()</code>.
Very old MediaWiki code may use <code>$dbw->query()</code>.
None of these are considered good practice now, and should be upgraded to the query builders mentioned above.

<translate><!--T:93--> Wrapper functions are superior to <tvar name=1><code>$dbw->query()</code></tvar>, because they can take care of things like table prefixes and escaping for you under some circumstances.</translate>
<translate><!--T:94--> If you really need to make your own SQL, please read the documentation for <tvar name=1><code>tableName()</code></tvar> and <tvar name=2><code>addQuotes()</code></tvar>.</translate>
<translate><!--T:186--> You will need both of them. Please keep in mind that failing to use <tvar name=1><code>addQuotes()</code></tvar> properly can introduce severe security holes into your wiki.</translate>

<translate><!--T:21--> Another important reason to use the high level methods rather than constructing your own queries is to ensure that your code will run properly regardless of the database type.</translate>
<translate><!--T:95--> Currently the best support is for MySQL/MariaDB. There is also good support for SQLite, however it is much slower than MySQL or MariaDB. There is support for PostgreSQL, but it is not as stable as MySQL.</translate>

<translate><!--T:22--> In the following, the available wrapper functions are listed.</translate>
<translate><!--T:96--> For a detailed description of the parameters of the wrapper functions, please refer to class <tvar name=Database>{{Class doclink|Wikimedia\Rdbms\Database|Database}}</tvar>'s docs.</translate>
<translate><!--T:97--> Particularly see <tvar name=select><code>{{Class doclink|Wikimedia\Rdbms\Database|anchor=a3b03dd27f434aabfc8d2d639d1e5fa9a|Database::select}}</code></tvar> for an explanation of the <tvar name=1><code>$table</code>, <code>$vars</code>, <code>$conds</code>, <code>$fname</code>, <code>$options</code>, <code>$join_conds</code></tvar> parameters that are used by many of the other wrapper functions.</translate>
{{Note|1=<translate><!--T:165--> The parameters <tvar name=1>{{phpi|$table}}</tvar>, <tvar name=2>{{phpi|$vars}}</tvar>, <tvar name=3>{{phpi|$conds}}</tvar>, <tvar name=4>{{phpi|$fname}}</tvar>, <tvar name=5>{{phpi|$options}}</tvar>, and <tvar name=6>{{phpi|$join_conds}}</tvar> should NOT be <tvar name=7>{{phpi|null}}</tvar> or <tvar name=8>{{phpi|false}}</tvar> (that was working until REL 1.35) but empty string <tvar name=9><code><nowiki>''</nowiki></code></tvar> or empty array <tvar name=10><code>[]</code></tvar>.</translate>}}

<syntaxhighlight lang="php" style="overflow:auto;">
function select( $table, $vars, $conds, .. );
function selectField( $table, $var, $cond, .. );
function selectRow( $table, $vars, $conds, .. );
function insert( $table, $a, .. );
function insertSelect( $destTable, $srcTable, $varMap, $conds, .. );
function update( $table, $values, $conds, .. );
function delete( $table, $conds, .. );
function deleteJoin( $delTable, $joinTable, $delVar, $joinVar, $conds, .. );
</syntaxhighlight>

<translate>
====Convenience functions==== <!--T:29-->
</translate>
{{MW 1.30|and earlier}}
<translate><!--T:30--> For compatibility with PostgreSQL, insert ids are obtained using <tvar name=1><code>nextSequenceValue()</code></tvar> and <tvar name=2><code>insertId()</code></tvar>.</translate>
<translate><!--T:102--> The parameter for <tvar name=1>{{phpi|nextSequenceValue()}}</tvar> can be obtained from the <tvar name=2><code>CREATE SEQUENCE</code></tvar> statement in <tvar name=3><code>{{git file|branch=REL1_30|file=maintenance/postgres/tables.sql}}</code></tvar> and always follows the format of <tvar name=4>x_y_seq</tvar>, with <tvar name=5>x</tvar> being the table name (e.g. <tvar name=6>page</tvar>) and <tvar name=7>y</tvar> being the primary key (e.g. <tvar name=8>page_id</tvar>), e.g. <tvar name=9>page_page_id_seq</tvar>.</translate>
<translate><!--T:103--> For example:</translate>

<syntaxhighlight lang="php">
$id = $dbw->nextSequenceValue( 'page_page_id_seq' );
$dbw->insert( 'page', [ 'page_id' => $id ] );
$id = $dbw->insertId();
</syntaxhighlight>

<translate>
<!--T:31-->
For some other useful functions, e.g. <tvar name=1>{{phpi|affectedRows()}}</tvar>, <tvar name=2>{{phpi|numRows()}}</tvar>, etc., see [[<tvar name=3>Special:MyLanguage/Manual:Database.php#Functions</tvar>|Manual:Database.php#Functions]].

==Basic query optimization== <!--T:32-->
</translate>
{{see also|Database optimization}}
<translate><!--T:33--> MediaWiki developers who need to write DB queries should have some understanding of databases and the [[<tvar name=1>Special:MyLanguage/Database optimization</tvar>|performance issues]] associated with them.</translate>
<translate><!--T:104--> Patches containing unacceptably slow features will not be accepted.</translate>
<translate><!--T:105--> Unindexed queries are generally not welcome in MediaWiki, except in special pages derived from <tvar name=1>{{ll|Manual:QueryPage.php|QueryPage}}</tvar>.</translate>
<translate><!--T:106--> It's a common pitfall for new developers to submit code containing SQL queries which examine huge numbers of rows.</translate>
<translate><!--T:107--> Remember that <tvar name=1><code>COUNT(*)</code></tvar> is [[w:Big O notation|O]](N), counting rows in a table is like counting beans in a bucket.</translate>

<translate>
==Backward compatibility== <!--T:160-->
</translate>
<translate><!--T:161--> Often, due to design changes to the DB, different DB accesses are necessary to ensure [[<tvar name=1>Special:MyLanguage/Backward compatibility</tvar>|backward compatibility]].</translate>
<translate><!--T:162--> This can be handled for example with the global constant <tvar name=2>MW_VERSION</tvar> (or global variable <tvar name=1>{{ll|Manual:$wgVersion|$wgVersion}}</tvar> before MediaWiki 1.39):</translate>

<syntaxhighlight lang="php" style="overflow:auto;">
/**
* backward compatibility
* @since 1.31.15
* @since 1.35.3
* define( 'DB_PRIMARY', ILoadBalancer::DB_PRIMARY )
* DB_PRIMARY remains undefined in MediaWiki before v1.31.15/v1.35.3
* @since 1.28.0
* define( 'DB_REPLICA', ILoadBalancer::DB_REPLICA )
* DB_REPLICA remains undefined in MediaWiki before v1.28
*/
defined('DB_PRIMARY') or define('DB_PRIMARY', DB_MASTER);
defined('DB_REPLICA') or define('DB_REPLICA', DB_SLAVE);

$res = WrapperClass::getQueryFoo();

class WrapperClass {

	public static function getReadingConnect() {
		return wfGetDB( DB_REPLICA );
	}

	public static function getWritingConnect() {
		return wfGetDB( DB_PRIMARY );
	}

	public static function getQueryFoo() {
		global $wgVersion;

		$param = '';
		if ( version_compare( $wgVersion, '1.33', '<' ) ) {
			$param = self::getQueryInfoFooBefore_v1_33();
		} else {
			$param = self::getQueryInfoFoo();
		}

		return = $dbw->select(
			$param['tables'],
			$param['fields'],
			$param['conds'],
			__METHOD__,
			$param['options'],
			$param['join_conds'] );
	}

	private static function getQueryInfoFoo() {
		return [
			'tables' => [
				't1' => 'table1',
				't2' => 'table2',
				't3' => 'table3'
			],
			'fields' => [
				'field_name1' => 't1.field1',
				'field_name2' => 't2.field2',
				…
			],
			'conds' => [ …
			],
			'join_conds' => [
				't2' => [
					'INNER JOIN',
					'field_name1 = field_name2'
				],
				't3' => [
					'LEFT JOIN',
					…
				]
			],
			'options' => [ …
			]
		];
	}

	private static function getQueryInfoFooBefore_v1_33() {
		return [
			'tables' => [
				't1' => 'table1',
				't2' => 'table2',
				't3' => 'table3_before'
			],
			'fields' => [
				'field_name1' => 't1.field1',
				'field_name2' => 't2.field2_before',
				…
			],
			'conds' => [ …
			],
			'join_conds' => [
				't2' => [
					'INNER JOIN',
					…
				],
				't3' => [
					'LEFT JOIN',
					…
				]
			],
			'options' => [ …
			]
		];
	}
}
</syntaxhighlight>
{{MW 1.35|+}}
<syntaxhighlight lang="php">
	public static function getQueryFoo() {

		$param = '';
		if ( version_compare( MW_VERSION, '1.39', '<' ) ) {
			$param = self::getQueryInfoFooBefore_v1_39();
		} else {
			$param = self::getQueryInfoFoo();
		}

		return = $dbw->select(
			$param['tables'],
			$param['fields'],
			$param['conds'],
			__METHOD__,
			$param['options'],
			$param['join_conds'] );
	}
</syntaxhighlight>
<translate>
==Replication== <!--T:34-->
</translate>
<translate><!--T:35--> Large installations of MediaWiki such as Wikipedia use a large set of replica MySQL servers replicating writes made to a primary MySQL server.</translate>
<translate><!--T:108--> It is important to understand the complexities associated with large distributed systems if you want to write code destined for Wikipedia.</translate>

<translate><!--T:36--> It's often the case that the best algorithm to use for a given task depends on whether or not replication is in use.</translate>
<translate><!--T:109--> Due to our unabashed Wikipedia-centrism, we often just use the replication-friendly version, but if you like, you can use <tvar name=1>{{phpi|wfGetLB()->getServerCount() > 1}}</tvar> to check to see if replication is in use.</translate>

<translate>
==Lag== <!--T:37-->
</translate>
<translate><!--T:38--> Lag primarily occurs when large write queries are sent to the primary server.</translate>
<translate><!--T:110--> Writes on the primary server are executed in parallel, but they are executed in serial when they are replicated to the replicas.</translate>
<translate><!--T:111--> The primary server writes the query to the binlog when the transaction is committed.</translate>
<translate><!--T:112--> The replicas poll the binlog and start executing the query as soon as it appears.</translate>
<translate><!--T:113--> They can service reads while they are performing a write query, but will not read anything more from the binlog and thus will perform no more writes.</translate>
<translate><!--T:114--> This means that if the write query runs for a long time, the replicas will lag behind the primary server for the time it takes for the write query to complete.</translate>

<translate><!--T:39--> Lag can be exacerbated by high read load.</translate>
<translate><!--T:115--> MediaWiki's load balancer will stop sending reads to a replica when it is lagged by more than 5 seconds.</translate>
<translate><!--T:116--> If the load ratios are set incorrectly, or if there is too much load generally, this may lead to a replica permanently hovering around 5 seconds lag.</translate>

<translate><!--T:40--> In Wikimedia production, databases have semi-sync enabled, meaning a change won't be committed in primary unless it's committed in at least half of the replicas. </translate>
<translate><!--T:179--> This means a lot of load could lead to all edits and other write operations to be refused, with an error returned to the user.</translate>
<translate><!--T:118--> This gives the replicas a chance to catch up.</translate>

<translate><!--T:119--> Before we had these mechanisms, the replicas would regularly lag by several minutes, making review of recent edits difficult.</translate>

<translate><!--T:41--> In addition to this, MediaWiki attempts to ensure that the user sees events occurring on the wiki in chronological order.</translate>
<translate><!--T:120--> A few seconds of lag can be tolerated, as long as the user sees a consistent picture from subsequent requests.</translate>
<translate><!--T:121--> This is done by saving the primary binlog position in the session, and then at the start of each request, waiting for the replica to catch up to that position before doing any reads from it.</translate>
<translate><!--T:122--> If this wait times out, reads are allowed anyway, but the request is considered to be in "lagged replica mode".</translate>
<translate><!--T:123--> Lagged replica mode can be checked by calling <tvar name=1>{{phpi|LoadBalancer::getLaggedReplicaMode()}}</tvar>.</translate>
<translate><!--T:124--> The only practical consequence at present is a warning displayed in the page footer.</translate>

<translate>
<!--T:80-->
Shell users can check replication lag with <tvar name=getLagTimes>{{ll|Manual:getLagTimes.php|getLagTimes.php}}</tvar>; other users can check using the <tvar name=siteinfo>{{ll|API:Siteinfo#dbrepllag|siteinfo}}</tvar> API.

<!--T:81-->
Databases often have their own monitoring systems in place as well, see for instance [[wikitech:MariaDB#Replication lag]] (Wikimedia) and [[wikitech:Help:Toolforge/Database#Identifying lag]] (Wikimedia Cloud VPS).

===Lag avoidance=== <!--T:42-->
</translate>
<translate><!--T:43--> To avoid excessive lag, queries that write large numbers of rows should be split up, generally to write one row at a time.</translate>
<translate><!--T:125--> Multi-row INSERT ... SELECT queries are the worst offenders and should be avoided altogether.</translate>
<translate><!--T:126--> Instead do the select first and then the insert.</translate>

<translate><!--T:150--> Even small writes can cause lag if they are done at a very high speed and replication is unable to keep up.</translate>
<translate><!--T:151--> This most commonly happens in maintenance scripts.</translate>
<translate><!--T:152--> To prevent it, you should call <tvar name=1>{{phpi|Maintenance::waitForReplication()}}</tvar> after every few hundred writes.</translate>
<translate><!--T:153--> Most scripts make the exact number configurable:</translate>

<syntaxhighlight lang="php">
class MyMaintenanceScript extends Maintenance {
    public function __construct() {
        // ...
        $this->setBatchSize( 100 );
    }

    public function execute() {
        $limit = $this->getBatchSize();
        while ( true ) {
             // ...<translate nowrap><!--T:154--> select up to <tvar name=1>$limit</tvar> rows to write, break the loop if there are no more rows</translate>...
             // ...<translate nowrap><!--T:155--> do the writes</translate>...
             $this->waitForReplication();
        }
    }
}
</syntaxhighlight>

<translate>
===Working with lag=== <!--T:44-->
</translate>
<translate><!--T:45--> Despite our best efforts, it's not practical to guarantee a low-lag environment.</translate>
<translate><!--T:127--> Replication lag will usually be less than one second, but may occasionally be up to 5 seconds.</translate>
<translate><!--T:128--> For scalability, it's very important to keep load on the primary server low, so simply sending all your queries to the primary server is not the answer.</translate>
<translate><!--T:129--> So when you have a genuine need for up-to-date data, the following approach is advised:</translate>

<translate>
<!--T:46-->
#Do a quick query to the primary server for a sequence number or timestamp 
#Run the full query on the replica and check if it matches the data you got from the primary server
#If it doesn't, run the full query on the primary server
</translate>

<translate><!--T:47--> To avoid swamping the primary server every time the replicas lag, use of this approach should be kept to a minimum.</translate>
<translate><!--T:130--> In most cases you should just read from the replica and let the user deal with the delay.</translate>

<translate>
==Lock contention== <!--T:48-->
</translate>
<translate><!--T:49--> Due to the high write rate on Wikipedia (and some other wikis), MediaWiki developers need to be very careful to structure their writes to avoid long-lasting locks.</translate>
<translate><!--T:131--> By default, MediaWiki opens a transaction at the first query, and commits it before the output is sent.</translate>
<translate><!--T:132--> Locks will be held from the time when the query is done until the commit.</translate>
<translate><!--T:133--> So you can reduce lock time by doing as much processing as possible before you do your write queries.</translate>
<translate><!--T:134--> Update operations which do not require database access can be delayed until after the commit by adding an object to <tvar name=1>{{wg|PostCommitUpdateList}}</tvar> or to <tvar name=2>{{phpi|Database::onTransactionPreCommitOrIdle}}</tvar>.</translate>

<translate><!--T:50--> Often this approach is not good enough, and it becomes necessary to enclose small groups of queries in their own transaction.</translate>
<translate><!--T:135--> Use the following syntax:</translate>

<syntaxhighlight lang="php">
$factory = \MediaWiki\MediaWikiServices::getInstance()->getDBLoadBalancerFactory();
$factory->beginMasterChanges(__METHOD__);
/* <translate nowrap><!--T:156--> Do queries</translate> */
$factory->commitMasterChanges(__METHOD__);
</syntaxhighlight>

<translate><!--T:52--> Use of locking reads (e.g. the FOR UPDATE clause) is not advised.</translate>
<translate><!--T:136--> They are poorly implemented in InnoDB and will cause regular deadlock errors.</translate>
<translate><!--T:137--> It's also surprisingly easy to cripple the wiki with lock contention.</translate>

<translate><!--T:53--> Instead of locking reads, combine your existence checks into your write queries, by using an appropriate condition in the WHERE clause of an UPDATE, or by using unique indexes in combination with INSERT IGNORE.</translate>
<translate><!--T:138--> Then use the affected row count to see if the query succeeded.</translate>

<translate>
==Database schema== <!--T:54-->
</translate>
<translate><!--T:55--> Don't forget about indexes when designing databases, things may work smoothly on your test wiki with a dozen of pages, but will bring a real wiki to a halt.</translate>
<translate><!--T:139--> See [[<tvar name=1>#Basic query optimization</tvar>|above]] for details.</translate>

<translate>
<!--T:56-->
For naming conventions, see <tvar name=1>{{ll|Manual:Coding conventions/Database}}</tvar>.

== See also == <!--T:66-->
</translate>
* {{ll|Manual:Hooks/LoadExtensionSchemaUpdates}} &mdash; <translate><!--T:67--> If an [[<tvar name=1>Special:MyLanguage/Manual:Extensions</tvar>|extension]] requires changes to the database when MediaWiki is updated, that can be done with this hook.</translate> <translate><!--T:173--> Users can then update their wiki by running <tvar name=1>{{ll|Manual:update.php|update.php}}</tvar>.</translate>
* {{ll|Database transactions}}

{{Databases}}

[[Category:Database{{#translation:}}|{{PAGENAME}}]]