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

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

Tento článek poskytuje přehled přístupu 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 pro tento účel.

Rozložení databáze

Informace o rozvržení databáze MediaWiki, například popis tabulek a jejich obsah, naleznete v rozložení Příručka:Databázové schéma . Historicky to bylo v MediaWiki zdokumentováno také na maintenance/tables.sql, ale počínaje MediaWiki 1.35 dochází v rámci iniciativy Abstract Schema, k postupnému přesunu na maintenance/tables.json. To znamená, že maintenance/tables.json se změní na maintenance/tables-generated.sql o maintenance script , což usnadňuje generování souborů schématu pro podporu různých databázových strojů.

Přihlášení do MySQL

Použití sql.php

MediaWiki poskytuje skript údržby pro přístup k databázi z maintenance adresáře údržby:

php sql.php

Poté můžete zapisovat databázové dotazy. Alternativně můžete zadat název souboru a MediaWiki jej spustí, přičemž podle potřeby nahradí všechny speciální proměnné MW. Více informací najdete na stránce 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> informacemi LocalSettings.php. Poté budete vyzváni k zadání hesla $wgDBpassword, po kterém se zobrazí výzva mysql>.

Vrstva abstrakce databáze

MediaWiki poskytuje abstrakční vrstvu databáze. Pokud nepracujete na abstrakční vrstvě, nikdy byste neměli přímo volat funkce databáze PHP (například mysql_query() nebo pg_send_query()).

K abstrakční vrstvě se přistupuje prostřednictvím třídy Wikimedia\Rdbms\Database. Příklad této třídy lze získat voláním getConnectionRef() (přednostně) nebo pomocí getConnection() vložením ILoadBalancer. Funkce wfGetDB() se postupně vyřazuje a neměla by se používat v novém kódu. Buď se obvykle volá s jediným parametrem, kterým může být konstantní DB_REPLICA (pro dotazy na čtení) nebo DB_PRIMARY (pro dotazy na psaní a čtení, které potřebují absolutně nejnovější informace). Rozdíl mezi základním a opakovaným je důležitý v prostředí více databází, jako je například Wikimedia. V části Balíčky funkcí (wrapper functions) níže najdete informace o tom, co můžete udělat s vráceným objektem Database.

Obálky výsledků výběrových dotazů jsou pole, jejichž klíče jsou celá čísla začínající na 1. K vytvoření dotazu pro čtení obvykle stačí něco takovéhoto:

$lb = MediaWikiServices::getInstance()->getDBLoadBalancer();
...
$dbr = $lb->getConnectionRef( DB_REPLICA );
$res = $dbr->select( /* ...see docs... */ );
foreach( $res as $row ) {
	...
}

Chcete-li napsat dotaz, použijte něco jako:

$dbw = $lb->getConnectionRef( DB_PRIMARY );
$dbw->insert( /* ...see docs... */ );

Používáme konvenci $dbr pro čtení a $dbw pro zápis, abychom vám pomohli sledovat, zda je databázový objekt replikou (pouze pro čtení) nebo primárním (čtení/zápis). Pokud napíšete do repliky, svět exploduje. Nebo abychom byli přesní, následný zápisový dotaz, který uspěl na primárním serveru, může selhat při replikaci do repliky kvůli jedinečné kolizi klíče. Replikace na replice se zastaví a oprava databáze a její opětovné zprovoznění může trvat hodiny. Nastavením read_only v my.cnf na replice se tomuto scénáři vyhnete, ale vzhledem k hrozným následkům dáváme přednost co největšímu počtu kontrol.

Funkce obálky

Poskytujeme funkci query() pro nezpracovaný SQL, ale funkce wrapperu jako select() a insert() jsou obvykle pohodlnější. Mohou se za určitých okolností postarat například o předvolby tabulek a escaping. Pokud opravdu potřebujete vytvořit svůj vlastní SQL, přečtěte si dokumentaci k tableName() a addQuotes(). Ob̟ě budete potřebovat. Nezapomeňte, že pokud nebudete správně používat addQuotes(), můžete do své wiki vložit závaž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 a $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 = '', $fname = 'Database::select', $options = [], $join_conds = [] );
function selectField( $table, $var, $cond = '', $fname = __METHOD__, $options = [] );
function selectRow( $table, $vars, $conds = '', $fname = 'Database::select', $options = [] );
function insert( $table, $a, $fname = 'Database::insert', $options = [] );
function insertSelect( $destTable, $srcTable, $varMap, $conds, $fname = 'Database::insertSelect', $insertOptions = [], $selectOptions = [] );
function update( $table, $values, $conds, $fname = 'Database::update', $options = [] );
function delete( $table, $conds, $fname = 'Database::delete' );
function deleteJoin( $delTable, $joinTable, $delVar, $joinVar, $conds, $fname = 'Database::deleteJoin' );
function buildLike(/*...*/);

Funkce wrapperu: select()

Funkce select() poskytuje rozhraní MediaWiki pro příkaz SELECT. Komponenty příkazu SELECT jsou kódovány jako parametry funkce select(). Zde je příklad:

$dbr = $lb->getConnectionRef( DB_REPLICA );
$res = $dbr->select(
	'category',                              // $table The table to query FROM (or array of tables)
	[ 'cat_title', 'cat_pages' ],            // $vars (columns of the table to SELECT)
	'cat_pages > 0',                         // $conds (The WHERE conditions)
	__METHOD__,                              // $fname The current __METHOD__ (for performance tracking)
	[ 'ORDER BY' => 'cat_title ASC' ]        // $options = []
);

Tento příklad odpovídá dotazu

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

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

$res = $dbw->select(
	[ 'watchlist', 'user_properties' ],
	[ 'wl_user' ],
	[
		'wl_user != 1' ,
		'wl_namespace' => '0',
		'wl_title' => 'Main_page',
		'up_property' => 'enotifwatchlistpages',
	],
	__METHOD__,
	[],
	[
		'user_properties' => [ 'INNER JOIN', [ 'wl_user=up_user' ] ]
	]
);

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'

Extension:OrphanedTalkPages poskytuje příklad jak používat tabulku aliasů v dotazech.

Argumenty jsou buď jednotlivé hodnoty (jako je 'category' a 'cat_pages > 0') nebo pole, pokud je pro pozici argumentu předána více než jedna hodnota (například ['cat_pages > 0', $myNextCond]). Pokud předáte řetězec třetím nebo pátým argumentům, musíte při vytváření řetězce ručně použít databázi Database::addQuotes(), pokud sestavujete řetězec, protože to za vás wrapper neudělá. Hodnoty pro názvy tabulek (1. argument) nebo názvy polí (2. argument) nesmějí být kontrolovány uživatelem. Konstrukce pole pro $conds je poněkud omezená. Může provádět pouze vztahy rovnosti a IS NULL (tj. WHERE key = 'value').

K jednotlivým řádkům výsledku můžete přistupovat pomocí smyčky foreach. Jakmile máte řádkový objekt, můžete použít operátor -> pro přístup ke konkrétnímu poli. Úplným příkladem může být:

$dbr = $lb->getConnectionRef( DB_REPLICA );
$res = $dbr->select(
	'category',                              // $table
	[ 'cat_title', 'cat_pages' ],            // $vars (columns of the table)
	'cat_pages > 0',                         // $conds
	__METHOD__,                              // $fname = 'Database::select',
	[ 'ORDER BY' => 'cat_title ASC' ]        // $options = []
);        
$output = '';
foreach( $res as $row ) {
        $output .= 'Category ' . $row->cat_title . ' contains ' . $row->cat_pages . " entries.\n";
}

Což vloží do proměnné $output abecední seznam kategorií s počtem položek, které má každá kategorie. Pokud vytváříte výstup jako HTML, ujistěte se, že jste hodnoty z databáze opustili pomocí htmlspecialchars()

Pohodlné funkce

MediaWiki version:
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.

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 pomocí globálních proměnných $wgDBprefix a $wgVersion :

$res = WrapperClass::getQueryFoo();

class WrapperClass {

	public static function getQueryFoo() {
		global $wgDBprefix, $wgVersion;

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

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

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

	private static function getQueryInfoFooBefore_v1_33( $prefix ) {
		return [
			'tables' => [ 'table1', 'table2', 'table3_before' ],
			'fields' => [
				'field_name1' => $prefix . 'table1.field1',
				'field_name2' => 'field2_before',
				
			],
			'conds' => [ 
			],
			'join_conds' => [
				'table2' => [
					'INNER JOIN',
					
				],
				'table3_before' => [
					'LEFT JOIN',
					
				]
			],
			'options' => [ 
			]
		];
	}
}

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 problémům spojeným s tímto nastavením.

Č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ž 30 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 30 sekund.

Pokud jsou všechny repliky zpožděny o více než 30 sekund (podle $wgDBservers ), MediaWiki přestane zapisovat do databáze. Všechny úpravy a další operace zápisu budou odmítnuty 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 wfGetLB()->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 kontrolovat zpoždění replikace pomocí getLagTimes.php . Ostatní uživatelé s rozhraním 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 LBFactory::waitForReplication(). Většina skriptů umožňuje konfigurovat přesné číslo:

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

    public function execute() {
        $lbFactory = MediaWikiServices::getInstance()->getDBLoadBalancerFactory();
        $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...
             $lbFactory->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ž 30 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:

  1. Proveďte rychlý dotaz na primární server na pořadové číslo nebo časové razítko
  2. Spusťte celý dotaz na repliku a zkontrolujte, zda odpovídá datům, které jste získali z primárního serveru
  3. 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 wiki) 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 .

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 Manual:Coding conventions/Database .

SQLite kompatibilita

Při psaní definic tabulek MySQL nebo aktualizacích oprav je důležité si uvědomit, že SQLite sdílí MySQL schéma, ale funguje to pouze tehdy, pokud jsou definice psány specifickým způsobem:

  • Primární klíče musí být deklarovány v deklaraci hlavní tabulky, ale normální klíče by měly být přidány samostatně s CREATE INDEX:
Špatně Správně
CREATE TABLE /*_*/foo (
    foo_id INT NOT NULL AUTO_INCREMENT,
    foo_text VARCHAR(256),
    PRIMARY KEY(foo_id),
    KEY(foo_text)
);
CREATE TABLE /*_*/foo (
    foo_id INT NOT NULL PRIMARY KEY AUTO_INCREMENT,
    foo_text VARCHAR(256)
) /*$wgDBTableOptions*/;

CREATE INDEX /*i*/foo_text ON /*_*/foo (foo_text);

Do definice hlavní tabulky by však měly být zahrnuty primární klíče zahrnující více než jedno pole:

CREATE TABLE /*_*/foo (
    foo_id INT NOT NULL,
    foo_text VARCHAR(256),
    PRIMARY KEY(foo_id, foo_text)
) /*$wgDBTableOptions*/;

CREATE INDEX /*i*/foo_text ON /*_*/foo (foo_text);
/*i*/ byl odstraněn z MediaWiki 1.35, viz Nahrazení proměnné.
  • Nepřidávejte do příkazu více než jeden sloupec:
Špatně Správně
ALTER TABLE /*_*/foo
    ADD foo_bar BLOB,
    ADD foo_baz INT;
ALTER TABLE /*_*/foo ADD foo_bar BLOB;
ALTER TABLE /*_*/foo ADD foo_baz INT;
  • Nastavte explicitní výchozí hodnoty při přidávání sloupců NOT NULL:
Špatně Správně
ALTER TABLE /*_*/foo ADD COLUMN foo_bar varchar(32) BINARY NOT NULL;
ALTER TABLE /*_*/foo ADD COLUMN foo_bar varchar(32) BINARY NOT NULL DEFAULT '';

Základní kontroly kompatibility můžete spustit pomocí:

Nebo, pokud potřebujete testovat aktualizaci, postupujte takto:

  • php sqlite.php --check-syntax tables.sql (s novým tables.sql)
  • php sqlite.php --check-syntax tables.sql filename.sql
    • Protože záplaty DB aktualizují také soubor tables.sql, pro tento by jste měli předat předběžnou verzi tables.sql (soubor s úplnou definicí DB). Jinak můžete získat chybu, pokud přetáhnete index (protože již neexistuje v tables.sql, protože jste jej právě odstranili).

Výše uvedené předpokládá, že jste v $IP/maintenance/, jinak zadejte úplnou cestu k souboru. Pro opravy rozšíření použijte ekvivalent těchto přípon.

Související stránky