Manual:Database access/nl

Dit artikel biedt een overzicht van toegang en algemene database kwesties in MediaWiki.

Wanneer u programmeert in MediaWiki, zult u normaal gesproken alleen de database gebruiken met behulp van MediaWiki-functies.



Database lay-out
Informatie over de MediaWiki database lay-out, bijvoorbeeld over tabellen en hun inhoud, lees. Dit was eerder gedocumenteerd in, maar vanaf MediaWiki 1.35 wordt dit beetje bij beetje verplaatst naar  , als onderdeel van het initiatief 'Abstract Schema'. Dat betekent dat  is omgezet naar   door een, dit maakt het gemakkelijker om schema-bestanden aan te maken om verschillende database engines te ondersteunen.



Inloggen in MySQL


Gebruik van sql.php
MediaWiki heeft een onderhoudsscript om de database te benaderen. Voer in de map maintenance uit:

U kunt dan een database query doen. U kunt ook een bestandsnaam opgeven, dat bestand wordt dan door MediaWiki uitgevoerd, waarbij elke MediaWiki speciale variabele wordt vervangen. Voor meer informatie, zie.

Dit werkt voor alle database backends. De prompt voor de commando-regel gebruikers bevat echter niet alle functies zoals die met uw database wordt meegeleverd.



De mysql commando-regel gebruiken
In LocalSettings.php staat uw MySQL wachtwoord en gebruikersnaam, bijvoorbeeld:

Met SSH, log in met deze gegevens:

Vervang en  met hun   waarden. Er wordt dan om uw wachtwoord gevraagd en vervolgens ziet u de prompt.



Database abstractie laag
MediaWiki gebruikt de Rdbms bibliotheek als de database abstractie laag. Het is niet de bedoeling dat ontwikkelaars direct de low-level database-functies aanroepen, zoals.

Elke connectie wordt weergegeven met  waar queries kunnen worden uitgevoerd. Er kan een connectie worden gemaakt door het aanroepen van   op een. instance, preferably dependency-injected, or obtained from MediaWikiServices, De functie  wordt afgebouwd en dient niet in nieuwe code te worden gebruikt.

wordt meestal met één parameter aangeroepen, of  bij queries om te lezen of   bij queries voor het schrijven (en voor write-informing read queries). Het verschil tussen primary en replica is belangrijk in een omgeving met meerdere databases, zoals Wikimedia. Lees de onderstaande sectie Wrapper functies om de interactie met de  objecten te zien.

Voorbeeld lezen:

""

Voorbeeld schrijven:

""

We gebruiken de conventie voor connecties om te lezen (replica) en  voor connecties om te schrijven (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:

Dit voorbeeld komt overeen met de volgende SQL:

Een JOIN is natuurlijk ook mogelijk:

Dit voorbeeld komt overeen met de query:

U kunt telkens een rij van het resultaat lezen met een foreach loop. Each row is represented as an object. Bijvoorbeeld:

Er zijn ook functies om een rij te lezen, een enkel veld uit meerdere rijen of een enkel veld uit een rij:

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



Wrapper functies
We bieden aan een query functie an voor pure SQL, maar met wrapper functies als select en insert is het meestal gemakkelijker. Deze zorgen voor het gebruik van prefixen en voor de foutafhandeling. Indien u echt uw eigen SQL wil maken, lees dan de documentatie over tableName en addQuotes. U heeft ze beide nodig. Als u niet goed addQuotes gebruikt dan kunnen er ernstige veiligheidsproblemen ontstaan op uw wiki.

Een andere reden om de high level methoden te gebruiken dan om zelf uw query te maken is de zekerheid dat uw code ook op andere database-types werkt. Op dit moment wordt MySQL/MariaDB het beste ondersteund. Er is ook goede ondersteuning voor SQLite, dat werkt wel trager dan MySQL en MariaDB. Er is ook ondersteuning voor PostgreSQL, maar dat is wat minder stabiel dan voor MySQL.

In deze paragraaf worden de beschikbare wrapper functies opgesomd. Een meer gedetailleerde beschrijving met ook de parameters van de wrapper functies staat in de class documenten. Bekijk vooral  voor een uitleg over de parameters ,  ,  ,  ,   en  , deze worden door veel andere wrapper functies gebruikt.



Wrapper functie: select
De functie select geeft de MediaWiki interface de mogelijkheid voor een SELECT-statement. De componenten van het SELECT-statement zijn de parameters van de functie select. Een voorbeeld

Dit voorbeeld komt overeen met de query

Een JOIN is natuurlijk ook mogelijk:

Dit voorbeeld komt overeen met de query

heeft een voorbeeld hoe een tabel alias in queries te gebruiken is.

Argumenten zijn of enkele waarden (zoals 'category' en 'cat_pages > 0') of arrays, indien meer dan een waarde wordt doorgegeven voor een argument positie (zoals ['cat_pages > 0', $myNextCond]). Als u als derde of vijfde argument een string opgeeft,dan moet u handmatig Database::addQuotes gebruiken op uw waarden als u de string aanmaakt, de wrapper doet dit niet voor u. De tabelnaam waarden (1e argument) of veldnamen (2e argument) moeten niet door de gebruiker kunnen worden opgegeven. De array constructie van $conds is een beetje beperkt, het kan alleen gelijkheid en   aan (bijv. WHERE key = 'value').

U kunt telkens een rij van het resultaat lezen met een foreach loop. Na het lezen van een row-object kunt u  gebruiken om een specifiek veld te lezen. Voorbeeld:

U krijgt nu een alfabetische lijst van categorieën met hoeveel records elke categorie heeft. Dat staat in de variabele $output. Als u de uitvoer als HTML wil doen, escape dan de waarden uit de database met.



Comfort functies
Om compatibel te zijn met PostgreSQL worden id's opgehaald met gebruik van nextSequenceValue en insertId. De parameter voor nextSequenceValue kan opgehaald worden met  statement in   en heeft het formaat  x_y_seq, waar x staat voor de tabelnaam (bijv. page) en y voor de primary key (bijv. page_id), bijv. page_page_id_seq. Bijvoorbeeld:

Er zijn andere mogelijk nuttige functies zoals, beschreven in  Handboek Database functies.



Basis query optimalisatie
MediaWiki ontwikkelaars die DB query's moeten schrijven, moeten verstand hebben van databases en de prestatie kwesties die deze met zich meebrengen. Patches die onacceptabele langzame functies bevatten worden niet geaccepteerd. Queries zonder index zijn in het algemeen niet welkom in MediaWiki, met uitzondering in Speciale Pagina's die afgeleid zijn van QueryPage. Het is voor nieuwe ontwikkelaars een bekende valkuil om code te maken die SQL-queries doen over een groot aantal records. Iets als COUNT(*) is O(N), het tellen van rijen in een tabel is als het tellen van zandkorrels op het strand.



Backwards compatibiliteit
Vaak zijn er door het wijzigen van het ontwerp van een database, verschillende toegangen nodig om zeker te zijn van compatibiliteit met oudere versies. Dit kan worden aangeven met bijvoorbeeld de globale variabelen en :

Replicatie
Grote installaties van MediaWiki zoals Wikipedia, gebruiken een groot aantal replica MySQL servers die writes op de primary MySQL-server ook doen. Het is van belang om te begrijpen welke gevolgen deze keuze heeft als u code voor Wikipedia wilt schrijven.

Het is vaak zo dat het beste algoritme voor een bepaalde taak afhangt of er wel of geen 'replication' wordt gebruikt. Vanwege onze gerichtheid op Wikipedia gebruiken we meestal gewoon de replication vriendelijke versie, maar als u het wilt dan kunt u gebruiken om te zien of er replication wordt gebruikt.

Achterlopen
Achterlopen (lag) komt voornamelijk voor als er grote write queries naar de primary server worden gestuurd. Op de primary server worden writes parallel uitgevoerd, maar op een replica server is dat serieel. De primary server schrijft de query naar de binlog bij de commit van de transactie. De replica's zien de actie op de binlog en voeren dan direct de query uit. Zij kunnen leesopdrachten afhandelen terwijl ze de schrijfactie doen, maar lezen dit niet meer van de binlog. Als de schrijfopdracht wat langer duurt dan lopen de replica's dus tijdens die opdracht wat achter.

Het achterlopen is afhankelijk van het aantal leesopdrachten. De load-balancer van MediaWiki zal geen leesopdrachten meer sturen naar een replica als er meer dan 30 seconden vertraging is. Als de load-ratio verkeerd wordt ingesteld of als er teveel load is, dan de vertraging van een replica blijvend rond de 30 seconden blijven schommelen.

Als dat bij alle replica's gebeurt (volgens ), dan zal MediaWiki het schrijven op de database stoppen. Alle bewerkingen en andere aanpassingen in de databse worden geweigerd met een foutmelding naar de gebruiker. Hierdoor kunnen de replica's hun achterstand inlopen. 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 hebben vaak ook een eigen monitoring systeem, zie bijvoorbeeld MariaDB (Wikimedia) en wikitech:Help:Toolforge/Database (Wikimedia Cloud VPS).

Lag avoidance
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:

Working with lag
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. Use the following syntax:

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.

Database schema
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. See above for details.

For naming conventions, see.

SQLite compatibility
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:


 * Don't add more than one column per statement:


 * Set explicit defaults when adding NOT NULL columns:

You can run basic compatibility checks with:


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



Zie ook

 * &mdash; If an extension requires changes to the database when MediaWiki is updated, that can be done with this hook. Users can then update their wiki by running.