Příručka:Přístup k databázi

This page is a translated version of the page Manual:Database access and the translation is 91% complete.

Outdated translations are marked like this.

Tento článek poskytuje přehled přístupů k databázi a obecných problémů s databází na MediaWiki.

Při kódování v MediaWiki budete obvykle přistupovat k databázi pouze prostřednictvím funkcí MediaWiki určených k tomuto účelu.

Schéma databáze

Pro aktuální informace o tom, jak vypadá databáze MediaWiki, jako například popis tabulek a jejich obsah, prostudujte Příručka:Schéma databáze . Historicky bylo dokumentováno v MediaWiki, též na maintenance/tables.sql, ale od verze 1.35 se postupně přešlo na sql/tables.json, což je součást iniciativy Abstract Schema. To znamená, že schéma ze sql/tables.json zapíše do souboru sql/mysql/tables-generated.sql maintenance script , což umožňuje na základě jedné konfigurace generovat databázová schémata, pro různé typy databází.

Přihlášení do MySQL

Použití sql.php

MediaWiki má pro práci s databází údržbářský skript, který může přistupovat k databázi. Ten se spouští z adresáře maintenance:

php run.php sql

Po jeho spuštění můžete zadávat dotazy na databázi. Další možnost je předat název souboru, který si bude spouštět MediaWiki, přičemž si MW podle potřeby nahradí všechny použité speciální proměnné. Pro další informace se podívejte na Manual:Sql.php .

To bude fungovat pro všechny databázové backendy. Výzva však není tak plnohodnotná jako klienti příkazového řádku dodávaní s vaší databází.

Použití klienta příkazového řádku mysql

## Nastavení databáze
$wgDBtype           = "mysql";
$wgDBserver         = "localhost";
$wgDBname           = "your-database-name";
$wgDBuser           = "your-database-username";  // Default: root
$wgDBpassword       = "your-password";

V LocalSettings.php najdete heslo a uživatelské jméno vaší wiki pro MySQL, například:

Do SSH se přihlaste zadáním následujícího:

mysql -u $wgDBuser -p --database=$wgDBname

Nahraďte $wgDBuser a $wgDBname jejich hodnotami LocalSettings.php. Poté budete vyzváni k zadání hesla $wgDBpassword a poté se zobrazí výzva mysql>.

Vrstva abstrakce databáze

MediaWiki používá knihovnu Rdbms jako svou abstrakční vrstvu databáze. Vývojáři nesmí přímo volat nízkoúrovňové databázové funkce, jako je mysql_query.

Každé připojení je reprezentováno Wikimedia\Rdbms\IDatabase, ze kterého lze provádět dotazy. Připojení lze získat voláním getPrimaryDatabase() nebo getReplicaDatabase() (v závislosti na případu použití) na instanci IConnectionProvider, nejlépe závislost-injected, nebo získat od MediaWikiServices prostřednictvím služby DBLoadBalancerFactory. Funkce wfGetDB() se postupně vyřazuje a neměla by se používat v novém kódu.

Chcete-li získat připojení k databázi, můžete zavolat buď getReplicaDatabase() pro čtecí dotazy nebo getPrimaryDatabase() pro zapisovací dotazy a čtecí dotazy informující o zápisu. Rozdíl mezi primární a replikou je důležitý v prostředí s více databázemi, jako je Wikimedie. Informace o tom, jak pracovat s objekty IDatabase, naleznete níže v části Funkce obálky.

Přečtěte si příklad dotazu:

Verze MediaWiki:

≥ 1.42

use MediaWiki\MediaWikiServices;

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

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

foreach ( $res as $row ) {
	print $row->foo;
}

Napište příklad dotazu:

Verze MediaWiki:

≥ 1.41

$dbw = $dbProvider->getPrimaryDatabase();
$dbw->newInsertQueryBuilder()
    ->insertInto( /* ... */ ) // see docs
    ->caller( __METHOD__ )->execute();

Používáme konvenci $dbr pro čitelná připojení (replika) a $dbw pro zapisovatelná připojení (primární). Také $dbProvider se používá pro instanci IConnectionProvider

SelectQueryBuilder

Verze MediaWiki:

≥ 1.35

Třída SelectQueryBuilder je preferovaný způsob, jak formulovat čtené dotazy v novém kódu. Ve starším kódu můžete najít select() a související metody třídy Database používané přímo. Tvůrce dotazů poskytuje moderní "plynulé" rozhraní, kde jsou metody zřetězené, dokud není vyvolána metoda načtení, bez nutnosti přiřazování zprostředkujících proměnných. Například:

$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();

As described below, MW 1.42 introduces a helper method, expr(), 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

->where( $dbr->expr( 'cat_pages', '>', 0 ) )

Tento příklad odpovídá následujícímu SQL:

SELECT cat_title, cat_pages FROM category WHERE cat_pages > 0 ORDER BY cat_title ASC

JOINs jsou také možné. Například:

$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();

Tento příklad odpovídá dotazu:

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'

K jednotlivým řádkům výsledku můžete přistupovat pomocí smyčky foreach. Každý řádek je reprezentován jako objekt. Například:

$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";
}

Existují také praktické funkce pro načtení jednoho řádku, jednoho pole z několika řádků nebo jednoho pole z jednoho řádku:

// 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();

V těchto příkladech je $pageRow objekt řádku jako ve výše uvedeném příkladu foreach, $pageIds je pole ID stránek a $pageId je jedno ID stránky.

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

UpdateQueryBuilder

Verze MediaWiki:

≥ 1.41

SQL UPDATE statements should be done with the UpdateQueryBuilder .

$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();

InsertQueryBuilder

Verze MediaWiki:

≥ 1.41

SQL INSERT statements should be done with the InsertQueryBuilder.

$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();

DeleteQueryBuilder

Verze MediaWiki:

≥ 1.41

SQL DELETE statements should be done with the DeleteQueryBuilder.

$dbw = $this->dbProvider->getPrimaryDatabase();
$dbw->newDeleteQueryBuilder()
	->deleteFrom( 'block' )
	->where( [ 'bl_id' => $ids ] )
	->caller( __METHOD__ )->execute();
$numDeleted = $dbw->affectedRows();

ReplaceQueryBuilder

Verze MediaWiki:

≥ 1.41

SQL REPLACE statements should be done with the ReplaceQueryBuilder.

$dbw = $this->dbProvider->getPrimaryDatabase();
$dbw->newReplaceQueryBuilder()
	->replaceInto( 'querycache_info' )
	->row( [
		'qci_type' => 'activeusers',
		'qci_timestamp' => $dbw->timestamp( $asOfTimestamp ),
	] )
	->uniqueIndexFields( [ 'qci_type' ] )
	->caller( __METHOD__ )->execute();

UnionQueryBuilder

Verze MediaWiki:

≥ 1.41

SQL UNION statements should be done with the UnionQueryBuilder.

$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();

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. update(), insertInto(), etc.), caller(), and execute() outside the loop. Anything related to creating or updating rows can go inside the loop (e.g. row()).

$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();

Helpers

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.

`$dbr->expr()`

Verze MediaWiki:

≥ 1.42

Should be used in WHERE statements whenever anything is being compared that isn't a simple equals statement. For example, $dbr->expr( 'ptrp_page_id', '>', $start ).

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

`$dbr->timestamp()`

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

RawSQLExpression

Verze MediaWiki:

≥ 1.42

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 $dbr->expr() instead. RawSQLExpression does not escape, so it should never be used with user input. Use sparingly! Example: $dbr->expr( new RawSQLExpression( 'rc_timestamp < fp_pending_since' ) )

RawSQLValue

Verze MediaWiki:

≥ 1.43

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 $dbr->expr() instead. RawSQLValue does not escape, so it should never be used with user input. Use sparingly! Example: $dbr->expr( 'fp_pending_since', '>', new RawSQLValue( $fieldName ) )

Funkce obálky a nezpracované dotazy

Older MediaWiki code may use wrapper functions like $dbr->select() and $dbw->insert(). Very old MediaWiki code may use $dbw->query(). None of these are considered good practice now, and should be upgraded to the query builders mentioned above.

Funkce Wrapper jsou lepší než $dbw->query(), protože se za vás za určitých okolností mohou postarat o věci, jako jsou předpony tabulek a escapování. Pokud opravdu potřebujete vytvořit vlastní SQL, přečtěte si prosím dokumentaci k tableName() a addQuotes(). Budete je potřebovat oba. Mějte prosím na paměti, že nesprávné použití addQuotes() může do vaší wiki vnést vážné bezpečnostní díry.

Dalším důležitým důvodem pro použití metod na vysoké úrovni, namísto vytváření vlastních dotazů, je zajištění správného fungování kódu bez ohledu na typ databáze. V současné době je nejlepší podpora pro MySQL/MariaDB. Existuje také dobrá podpora pro SQLite, je však mnohem pomalejší než MySQL nebo MariaDB. Existuje podpora pro PostgreSQL, ale není tak stabilní jako MySQL.

V následující části jsou uvedeny dostupné funkce obálky. Podrobný popis parametrů funkcí obálky (wrapper) najdete v dokumentech třídy Database's. Zejména viz Database::select pro vysvětlení $table, $vars, $conds, $fname, $options, $join_conds parametrů, které používá mnoho dalších funkcí wrapperu.

Parametry $table, $vars, $conds, $fname, $options a $join_conds NESMÍ být null nebo false (to fungovalo do REL 1.35), ale prázdný řetězec '' nebo prázdné pole [].

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, .. );

Pohodlné funkce

Verze MediaWiki:

≤ 1.30

Pro kompatibilitu s PostgreSQL jsou idy vložení získány pomocí nextSequenceValue() a insertId(). Parametr pro nextSequenceValue() lze získat z příkazu CREATE SEQUENCE v maintenance/postgres/tables.sql a vždy odpovídá formátu x_y_seq, kde x je název tabulky (např. page) a y je primární klíč (např. page_id), např. page_page_id_seq. Například:

$id = $dbw->nextSequenceValue( 'page_page_id_seq' );
$dbw->insert( 'page', [ 'page_id' => $id ] );
$id = $dbw->insertId();

Pro některé další užitečné funkce, např. affectedRows(), numRows() atd., viz Příručka:Database.php#Functions.

Základní optimalizace dotazu

Vývojáři MediaWiki, kteří potřebují psát dotazy na DB, by měli mít určité znalosti o databázích a s nimi spojenými problémy s výkonem. Opravy obsahující nepřijatelně pomalé funkce nebudou přijaty. Neindexované dotazy nejsou na MediaWiki obecně vítány, s výjimkou zvláštních stránek odvozených z QueryPage . Pro nové vývojáře je obvyklé předkládat kód obsahující dotazy SQL, které zkoumají obrovské množství řádků. Pamatujte, že COUNT(*) je O(N), počítání řádků v tabulce je jako počítání fazolí v kbelíku.

Zpětná kompatibilita

Kvůli změnám návrhu DB jsou často nutné různé přístupy k DB pro zajištění zpětné kompatibility. To lze zpracovat například globální konstantou MW_VERSION (nebo globální proměnnou $wgVersion před MediaWiki 1.39):

/**
* 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' => [ …
			]
		];
	}
}

Verze MediaWiki:

≥ 1.35

	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'] );
	}

Replikace

Velké instalace MediaWiki, jako je Wikipedie, používají velkou sadu replik MySQL serverů replikujících zápisy provedené na primární MySQL server. Pokud chcete psát kód určený pro Wikipedii, je důležité porozumět složitosti spojené s velkými distribuovanými systémy.

Často se stává, že nejlepší algoritmus pro daný úkol závisí na tom, zda se používá replikace. Kvůli našemu neustálému centrování na Wikipedii často používáme pouze verzi vhodnou pro replikaci. Ale pokud chcete, můžete použít wfGetLB()->getServerCount() > 1 a zkontrolovat, zda se replikace používá.

Prodleva

K nadměrnému zpoždění (lag) dochází především při odesílání velkých dotazů na zápis na primární server. Zápisy na primárním serveru jsou prováděny paralelně, ale jsou prováděny sériově, když jsou replikovány do replik. Primární server zapíše dotaz do binlogu, když je transakce potvrzena. Repliky se dotazují na binlog a začnou provádět dotaz, jakmile se objeví. Mohou číst služby, zatímco provádějí dotaz na zápis, ale nebudou číst nic víc z binlogu a nebudou tedy provádět žádné další zápisy. To znamená, že pokud dotaz na zápis běží dlouhou dobu, repliky budou za primárním serverem zaostávat po dobu, kterou trvá dokončení dotazu na zápis.

Zpoždění může být umocněno vysokou zátěží čtením. Nástroj pro vyrovnávání zátěže MediaWiki přestane odesílat čtení do repliky, když se zpozdí o více než 5 sekund. Pokud jsou poměry zatížení nastaveny nesprávně nebo pokud je zatížení obecně příliš velké, může to vést k tomu, že se replika trvale pohybuje se zpožděním 5 sekund.

V produkci Wikimedie mají databáze povolenou semi-synchronizaci, což znamená, že změna nebude potvrzena primárně, pokud nebude potvrzena alespoň v polovině replik. To znamená, že velké zatížení může vést k odmítnutí všech úprav a dalších operací zápisu s chybou vrácenou uživateli. To dává replikám šanci vše dohnat.

Než jsme měli tento mechanismus, repliky se pravidelně zpožďovaly o několik minut, což ztěžovalo kontrolu posledních úprav.

Kromě toho se MediaWiki snaží zajistit, aby uživatel viděl události na wiki v chronologickém pořadí. Několik sekund zpoždění může být tolerováno, pokud uživatel uvidí konzistentní obrázek z následných požadavků. To se provádí uložením pozice primárního binlogu v relaci a poté na začátku každého požadavku čekáním, až replika dožene tuto pozici, než z ní provedete jakékoli čtení. Pokud toto čekání vyprší, čtení je přesto povoleno, ale požadavek je považován, že je v "režimu zpožděné repliky". Režim opožděné repliky lze zkontrolovat voláním LoadBalancer::getLaggedReplicaMode(). Jediným praktickým důsledkem v současné době je varování zobrazené v zápatí stránky.

Uživatelé prostředí Shell mohou zkontrolovat zpoždění replikace pomocí getLagTimes.php . Ostatní uživatelé mohou zkontrolovat pomocí siteinfo API.

Databáze mají často také své vlastní monitorovací systémy, viz například wikitech:MariaDB#Replication lag (Wikimedie) a wikitech:Help:Toolforge/Database#Identification lag (Wikimedie Cloud VPS).

Vyhýbání se zpoždění

Chcete-li se vyhnout nadměrnému zpoždění, měly by se dotazy, které píší velké množství řádků, rozdělit. Obvykle psát vždy jeden řádek najednou. Víceřádkové VLOŽIT (INSERT) ... VYBRAT (SELECT) dotazy jsou nejhorší pachatelé a je třeba se jim úplně vyhnout. Místo toho proveďte nejprve výběr a poté vložení.

I malé zápisy mohou způsobit zpoždění, pokud jsou prováděny velmi vysokou rychlostí a replikace není schopna držet krok. Nejčastěji se to stává ve skriptech údržby. Abyste tomu zabránili, měli byste po každých několika stovkách zápisů volat Maintenance::waitForReplication(). Většina skriptů umožňuje konfigurovat přesné číslo:

class MyMaintenanceScript extends Maintenance {
    public function __construct() {
        // ...
        $this->setBatchSize( 100 );
    }

    public function execute() {
        $limit = $this->getBatchSize();
        while ( true ) {
             // ...vyberte až $limit řádků k zápisu, přerušte smyčku, pokud nejsou žádné další řádky...
             // ...dělat zápisy...
             $this->waitForReplication();
        }
    }
}

Práce se zpožděním

I přes naše nejlepší úsilí není praktické zaručit prostředí s malým zpožděním. Zpoždění replikace bude obvykle kratší než jedna sekunda, ale někdy může být až 5 sekund. Pro škálovatelnost je velmi důležité udržovat nízké zatížení primárního serveru, takže pouhé odesílání všech vašich dotazů na primární server není řešením. Pokud tedy skutečně potřebujete aktuální data, doporučuje se následující postup:

Proveďte rychlý dotaz na primární server na pořadové číslo nebo časové razítko
Spusťte celý dotaz na repliku a zkontrolujte, zda odpovídá datům, které jste získali z primárního serveru
Pokud ne, spusťte celý dotaz na primárním serveru

Aby nedošlo k zaplavení primárního serveru pokaždé, když se repliky zpozdí, použití tohoto přístupu by mělo být omezeno na minimum. Ve většině případů byste měli pouze číst z repliky a nechat uživatele, aby se se zpožděním vypořádal.

Uzamčení sporu

Vzhledem k vysoké míře zápisu na Wikipedii (a některých dalších wikinách) musí být vývojáři MediaWiki velmi opatrní při strukturování svých zápisů, aby se vyhnuli dlouhodobým uzamčením. Ve výchozím nastavení MediaWiki otevře transakci při prvním dotazu a potvrdí ji před odesláním výstupu. Zámky se budou držet od doby, kdy je dotaz proveden, až po potvrzení. Takže můžete zkrátit dobu uzamčení provedením co nejvíce zpracování, než začnete psát dotazy. Operace aktualizace, které nevyžadují přístup k databázi, mohou být zpožděny až po odevzdání přidáním objektu do $wgPostCommitUpdateList nebo do Database::onTransactionPreCommitOrIdle.

Tento přístup často není dost dobrý a je nutné uzavřít malé skupiny dotazů do jejich vlastní transakce. Použijte následující syntaxi:

$factory = \MediaWiki\MediaWikiServices::getInstance()->getDBLoadBalancerFactory();
$factory->beginMasterChanges(__METHOD__);
/* Dotazy */
$factory->commitMasterChanges(__METHOD__);

Použití blokovacích čtení (např. klauzule FOR UPDATE) se nedoporučuje. Jsou špatně implementovány v InnoDB a způsobí pravidelné chyby zablokování. Je také překvapivě snadné ochromit wiki s tvrzením o uzamčení.

Namísto zamykání čtení zkombinujte své existenční kontroly do svých písemných dotazů pomocí vhodné podmínky v klauzuli WHERE UPDATE nebo pomocí jedinečných indexů v kombinaci s INSERT IGNORE. Potom pomocí ovlivněného počtu řádků zjistěte, zda byl dotaz úspěšný.

Schéma databáze

Při vytváření databází nezapomeňte na indexy, na zkušební wiki s desítkami stránek může vše hladce fungovat, ale skutečná wiki se zastaví. Podrobnosti najdete výše.

Konvence pojmenování najdete na stránce Příručka:Konvence pro psaní kódu/Database .

Související odkazy

Příručka:Háčky/LoadExtensionSchemaUpdates — Pokud rozšíření při aktualizaci MediaWiki vyžaduje změny v databázi, lze to provést pomocí tohoto háčku. Uživatelé pak mohou aktualizovat svou wiki spuštěním update.php .
Databázové transakce