Manual:Database access/de

Dieser Artikel gibt einen Überblick über den Datenbankzugriff und allgemeine Datenbankthemen im MediaWiki.

Beim Kodieren in MediaWiki wird für gewöhnlich nur über die dafür vorgesehenen Funktionen von MediaWiki auf die Datenbank zugegriffen.



Datenbankschema
Informationen über das MediaWiki-Datenbank-Layout, wie z.B. eine Beschreibung der Tabellen und ihrer Inhalte, finden sich unter und $tables. Historically in MediaWiki, this was also documented in, however, starting in MediaWiki 1.35, this is being gradually moved into   as part of the Abstract Schema initiative. This means the  is turned into   by a, making it easier to generate schema files to support different database engines.



Einloggen in MySQL


sql.php verwenden
MediaWiki bietet ein Wartungsskript für den Zugriff auf die Datenbank. Aus dem maintenance-Verzeichnis ausführen:

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. Für mehr Informationen siehe.

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.



mysql-Kommandozeilenbefehle verwenden
Das MySQL-Passwort und den Benutzernamen finden sich in LocalSettings.php des Wikis, beispielsweise:

Via SSH meldet man sich mit folgender Eingabe an:

Dabei sind und  durch ihre Werte in   zu ersetzen. Danach wird die Eingabe des Passwortes für erwartet, woraufhin die Eingabeaufforderung   erscheint.



Databack-Abstraktionsschicht
MediaWiki uses the Rdbms library as its database abstraction layer. Developers must not directly call low-level database functions, such as.

Each connection is represented by   from which queries can be performed. Connections can be acquired by calling   on a. instance, preferably dependency-injected, or obtained from MediaWikiServices, The function  is being phased out and should not be used in new code.

is typically called with a single parameter, either  for read queries or   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 Wrapper functions section below for how to interact with  objects.

Read query example:

""

Write query example:

""

We use the convention for readable connections (replica) and  for writable connections (primary).

SelectQueryBuilder
The class is the preferred way to formulate read queries in new code. In older code, you might find  and related methods of the Database class used directly. The query builder provides a modern "fluent" interface, where methods are chained until the fetch method is invoked, without intermediary variable assignments needed. For example:

This example corresponds to the following SQL:

JOINs sind auch möglich; zum Beispiel:

This example corresponds to the query:

You can access individual rows of the result using a foreach loop. Each row is represented as an object. For example:

There are also convenience functions to fetch a single row, a single field from several rows, or a single field from a single row:

In these examples, is an row object as in the  example above, is an array of page IDs, and is a single page ID.



Ummantelungsfunktionen
We provide a query function for raw SQL, but the wrapper functions like select and insert are usually more convenient. They can take care of things like table prefixes and escaping for you under some circumstances. If you really need to make your own SQL, please read the documentation for tableName and addQuotes. You will need both of them. Please keep in mind that failing to use addQuotes properly can introduce severe security holes into your wiki.

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. 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.

In the following, the available wrapper functions are listed. For a detailed description of the parameters of the wrapper functions, please refer to class 's docs. Particularly see  for an explanation of the ,  ,  ,  ,  , and   parameters that are used by many of the other wrapper functions.



Ummantelungsfunktion: select
The select function provides the MediaWiki interface for a SELECT statement. The components of the SELECT statement are coded as parameters of the select function. Ein Beispiel:

Dieses Beispiel entspricht der Abfrage

JOINs sind auch möglich; zum Beispiel:

Dieses Beispiel entspricht der Abfrage

bietet ein Beispiel für die Verwendung von Tabellen-Aliasen in Abfragen.

Arguments are either single values (such as 'category' and 'cat_pages > 0') or arrays, if more than one value is passed for an argument position (such as ['cat_pages > 0', $myNextCond]). If you pass in strings to the third or fifth argument, you must manually use Database::addQuotes on your values as you construct the string, as the wrapper will not do this for you. The values for table names (1st argument) or field names (2nd argument) must not be user controlled. The array construction for $conds is somewhat limited; it can only do equality and  relationships (i.e. WHERE key = 'value').

You can access individual rows of the result using a foreach loop. Once you have a row object, you can use the  operator to access a specific field. Ein umfangreiches Beispiel:

Which will put an alphabetical list of categories with how many entries each category has in the variable $output. If you are outputting as HTML, ensure to escape values from the database with



Komfortfunktionen
For compatibility with PostgreSQL, insert ids are obtained using nextSequenceValue and insertId. The parameter for nextSequenceValue can be obtained from the  statement in   and always follows the format of x_y_seq, with x being the table name (e.g. page) and y being the primary key (e.g. page_id), e.g. page_page_id_seq. Zum Beispiel:

For some other useful functions, e.g., , etc., see Manual:Database.php#Functions.



Grundlegende Abfrageoptimierung
MediaWiki developers who need to write DB queries should have some understanding of databases and the performance issues associated with them. Patches containing unacceptably slow features will not be accepted. Unindexed queries are generally not welcome in MediaWiki, except in special pages derived from QueryPage. It's a common pitfall for new developers to submit code containing SQL queries which examine huge numbers of rows. Remember that COUNT(*) is O(N), counting rows in a table is like counting beans in a bucket.



Abwärtskompatibilität
Oftmals sind aufgrund von Design-Änderungen an der DB verschiedene DB-Zugriffe notwendig, um Rückwärtskompatibilität zu gewährleisten. Dies lässt sich beispielsweise mit der globalen Variablen so handhaben:

Vervielfältigung
Large installations of MediaWiki such as Wikipedia, use a large set of replica MySQL servers replicating writes made to a primary MySQL server. It is important to understand the issues associated with this setup if you want to write code destined for Wikipedia.

It's often the case that the best algorithm to use for a given task depends on whether or not replication is in use. Due to our unabashed Wikipedia-centrism, we often just use the replication-friendly version, but if you like, you can use to check to see if replication is in use.

Verzögerung
Die Verzögerung tritt vor allem dann auf, wenn große Schreibanfragen an den Master gesendet werden. Writes on the primary server are executed in parallel, but they are executed in serial when they are replicated to the replicas. The primary server writes the query to the binlog when the transaction is committed. The replicas poll the binlog and start executing the query as soon as it appears. 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. 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.

Lag can be exacerbated by high read load. MediaWiki's load balancer will stop sending reads to a replica when it is lagged by more than 30 seconds. If the load ratios are set incorrectly, or if there is too much load generally, this may lead to a replica permanently hovering around 30 seconds lag.

If all replicas are lagged by more than 30 seconds (according to ), MediaWiki will stop writing to the database. All edits and other write operations will be refused, with an error returned to the user. This gives the replicas a chance to catch up. Before we had this mechanism, the replicas would regularly lag by several minutes, making review of recent edits difficult.

In addition to this, MediaWiki attempts to ensure that the user sees events occurring on the wiki in chronological order. A few seconds of lag can be tolerated, as long as the user sees a consistent picture from subsequent requests. 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. If this wait times out, reads are allowed anyway, but the request is considered to be in "lagged replica mode". Lagged replica mode can be checked by calling. The only practical consequence at present is a warning displayed in the page footer.

Shell users can check replication lag with ; other users can check using the API.

Databases often have their own monitoring systems in place as well, see for instance MariaDB (Wikimedia) and wikitech:Help:Toolforge/Database (Wikimedia Cloud VPS).



Verzögerungsvermeidung
To avoid excessive lag, queries that write large numbers of rows should be split up, generally to write one row at a time. Multi-row INSERT ... SELECT queries are the worst offenders and should be avoided altogether. Instead do the select first and then the insert.

Even small writes can cause lag if they are done at a very high speed and replication is unable to keep up. This most commonly happens in maintenance scripts. To prevent it, you should call after every few hundred writes. Most scripts make the exact number configurable:



Mit Verzögerung arbeiten
Despite our best efforts, it's not practical to guarantee a low-lag environment. Replication lag will usually be less than one second, but may occasionally be up to 30 seconds. 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. So when you have a genuine need for up-to-date data, the following approach is advised:


 * 1) Do a quick query to the primary server for a sequence number or timestamp
 * 2) Run the full query on the replica and check if it matches the data you got from the primary server
 * 3) If it doesn't, run the full query on the primary server

To avoid swamping the primary server every time the replicas lag, use of this approach should be kept to a minimum. In most cases you should just read from the replica and let the user deal with the delay.

Lock contention
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. By default, MediaWiki opens a transaction at the first query, and commits it before the output is sent. Locks will be held from the time when the query is done until the commit. So you can reduce lock time by doing as much processing as possible before you do your write queries. Update operations which do not require database access can be delayed until after the commit by adding an object to.

Often this approach is not good enough, and it becomes necessary to enclose small groups of queries in their own transaction. Folgende Syntax ist zu verwenden:

Use of locking reads (e.g. the FOR UPDATE clause) is not advised. They are poorly implemented in InnoDB and will cause regular deadlock errors. It's also surprisingly easy to cripple the wiki with lock contention.

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. Then use the affected row count to see if the query succeeded.



Datenbankschema
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. Siehe oben für Einzelheiten.

Für Namenskonventionen siehe.



MediWiki mit SQLite
When writing MySQL table definitions or upgrade patches, it is important to remember that SQLite shares MySQL's schema, but that works only if definitions are written in a specific way:


 * Primary keys must be declared within main table declaration, but normal keys should be added separately with CREATE INDEX:

However, primary keys spanning over more than one field should be included in the main table definition:


 * Nicht mehr als eine Spalte pro Anweisung hinzufügen:


 * Beim Hinzufügen von -Spalten sind explizite Vorgabewerte zu setzen:

Grundlegende Kompatibilitätsprüfungen können durchgeführt werden mit:


 * - MediaWiki 1.36+
 * - MediaWiki 1.35 and earlier

Or, if you need to test an update patch, both:


 * - MediaWiki 1.36+
 * - MediaWiki 1.35 and earlier
 * Since DB patches update the tables.sql file as well, for this one you should pass in the pre-commit version of tables.sql (the file with the full DB definition). Otherwise, you can get an error if you e.g. drop an index (since it already doesn't exist in tables.sql because you just removed it).

The above assumes you're in $IP/maintenance/, otherwise, pass the full path of the file. For extension patches, use the extension's equivalent of these files.



Siehe auch

 * &mdash; Erfordert eine Erweiterung Änderungen an der Datenbank, wenn MediaWiki aktualisiert wird, kann dies mit diesem Hook erledigt werden. Benutzer können dann ihr Wiki aktualisieren, indem sie ausführen.