Duurzaamheid in het bedrijfsleven is moeilijk zonder goed gegevensbeheer. Het bouwen van een goed gedefinieerd systeem is essentieel voor het beheren van interne en externe activiteiten. Gedetailleerd inzicht in bedrijfsgegevens helpt om de algehele workflow te begrijpen en prestaties te meten. Bovendien bespaart het gebruik van databases tijd en maakt het moeiteloos openen van informatie mogelijk.
Wat is een database?
Een database is een georganiseerd systeem dat wordt gebruikt om informatie op een veilige manier op te slaan. Het biedt categorisatie en maakt het mogelijk om tabellen te maken om vergelijkbare soorten items onder één groep te sorteren. Tabellen bieden opties om informatie in meerdere rijen en kolommen weer te geven. Als gevolg hiervan verbeteren de kwaliteit en consistentie van gegevens. Naast opslag en gemakkelijk toegankelijke mogelijkheden, spelen databases een belangrijke rol bij het waarborgen van privacy en het beveiligen van systemen. Of het nu ad hoc is of deel uitmaakt van een proces dat in een applicatie is gecodeerd, het ophalen van gegevens is een van de meest kritieke aspecten van databasebeheer.
Een query in relationele DMS is elk commando dat wordt gebruikt om gegevens uit een tabel op te halen. SELECT-instructies worden bijna altijd gebruikt in Structured Query Language-query's (SQL). Er zijn verschillende methoden om informatie uit een database op te halen. Over het algemeen geven ontwikkelaars de voorkeur aan de opdrachtregeloptie omdat deze snel en effectief is. Hiermee kunnen query's naadloos worden ingediend.
In deze handleiding introduceren we MySQL en bespreken we hoe u met query's in MySQL kunt werken. Laten we beginnen!
Vereisten
Om deze handleiding te volgen, heeft u het volgende nodig:
-
De nieuwste versie van Ubuntu is geïnstalleerd op uw systeem.
-
Systeemgebruikers moeten sudo-privileges hebben.
-
Als u problemen ondervindt bij de toegang tot uw sudo-account, overweeg dan om het MySQL root-wachtwoord te wijzigen.
-
-
MySQL is ingesteld op uw server.
Stap 1 — Een database maken en instellen
Voordat we beginnen en onze eerste SQL-query schrijven, moeten we een database maken en er tabellen aan toevoegen. Daarna zullen we de tabellen vullen met voorbeeldgegevens. Het werken met databases zal u helpen de basisopzet te begrijpen en vertrouwen te krijgen in het werken met query's.
Praktijkervaring is de meest effectieve manier om concepten op te bouwen en het belang van databases te begrijpen. In deze handleiding leiden we u door het gebruik van databases en hun betekenis voor het oplossen van echte problemen. Laten we een scenario bekijken om te begrijpen hoe databases kunnen helpen om records op een gestructureerde manier te organiseren.
Scenario: We maken een database waarin een groep studenten op vakantie gaat om hun verjaardagen te vieren. Voordat ze op vakantie gaan, zijn ze van plan deel te nemen aan een vriendschappelijke zwemwedstrijd. Ook plant elke vriend in de groep een to-do-lijst met activiteiten om hun reis spannend en plezierig te maken.
Open eerst MySQL als de root-gebruiker:
|
1 |
$ sudo mysql |
Maak vervolgens een database door de volgende opdracht uit te voeren:
|
1 2 3 |
mysql> CREATE DATABASE `vacation`; Query OK, 1 row affected (0.52 sec) |
Laten we vervolgens onze database gebruiken met de volgende opdracht:
|
1 |
mysql> USE vacation; |
Daarna maken we tabellen in onze database. Noem de eerste tabel celebration. Onze tabel krijgt kolommen voor de namen van onze vrienden (name), de toernooien die ze hebben gewonnen (wins) en ook een kolom voor hun beste tijd (time):
|
1 2 3 4 5 6 7 |
mysql> CREATE TABLE celebration ( -> name varchar(50), -> wins real, -> time real -> ); Query OK, 0 rows affected (2.03 sec) |
We zullen onze tabel vervolgens vullen met gegevens:
|
1 2 3 4 5 6 7 8 9 |
mysql> INSERT INTO celebration (name, wins, time) VALUES('Austin', '4', '15.5'), ('Ivan','7','9'), ('Aisha','10','5'), ('Zane','13','7.5'); Query OK, 4 rows affected (0.29 sec) Records: 4 Duplicates: 0 Warnings: 0 |
Maak vervolgens nog een tabel aan in onze database om informatie over hun favoriete verjaardagsactiviteiten op te slaan. We maken een tabel genaamd vacation en krijgt de volgende kolommen:
|
Lijst |
Detail |
|
name: |
Sla de naam van elke vriend op. |
|
birthdate: |
Houdt de geboortedatum van elk individu bij. |
|
activity: |
Houdt hun favoriete activiteit bij. |
|
Destination: |
Slaat de informatie op van de favoriete bestemming van elk individu. |
|
meal: |
Houdt de favoriete maaltijd van een individu bij. |
|
1 2 3 4 5 6 7 8 |
mysql> CREATE TABLE vacation ( name varchar(50), birthdate date, activity varchar(50), destination varchar(50), meal varchar(50) ); Query OK, 0 rows affected (0.09 sec) |
Vul de tabel met gegevens:
|
1 2 3 4 5 6 7 8 9 10 |
mysql> CREATE TABLE vacation ( name varchar(50), birthdate date, activity varchar(50), destination varchar(50), meal varchar(50) ); Query OK, 0 rows affected (0.09 sec) Records: 4 Duplicates: 0 Warnings: 0 |
Je bent nu klaar met het opzetten van je database.
Stap 2 — Aan de slag met SELECT-statements
Query's in SQL beginnen normaal gesproken met SELECT. Dit wordt in query's gebruikt om aan te geven welke kolommen in een tabel met de resultaten moeten worden geretourneerd. Een query moet ook altijd FROM, wat wordt gebruikt om de tabel te specificeren waarop het statement de query zal uitvoeren.
Query's volgen de onderstaande syntaxis:
|
1 |
mysql> SELECT column_to_select FROM table_to_select WHERE certain_conditions_apply; |
We zullen de querysyntaxis gebruiken om de kolom meal uit de tabel vacation te retourneren:
|
1 |
mysql> SELECT meal FROM vacation; |
Onze uitvoer zal als volgt zijn:
|
1 2 3 4 5 6 7 8 9 10 |
+-------+ | meal | +-------+ | Steak | | Sushi | | Fries | | Tofu | +-------+ 4 rows in set (0.00 sec) |
Je kunt ook meerdere kolommen selecteren door een komma te gebruiken om ze te scheiden:
|
1 |
mysql> SELECT name, destination FROM vacation; |
Uitvoer:
|
1 2 3 4 5 6 7 8 9 10 |
+--------+-------------+ | name | destination | +--------+-------------+ | Austin | Maldives | | Ivan | Mauritius | | Aisha | Colorado | | Zane | Bora Bora | +--------+-------------+ 4 rows in set (0.00 sec) |
Je kunt ook een asterisk (*) gebruiken als je alle kolommen in de tabel wilt weergeven:
|
1 |
mysql> SELECT * FROM celebration; |
Uitvoer:
|
1 2 3 4 5 6 7 8 9 10 |
+--------+------+------+ | name | wins | time | +--------+------+------+ | Austin | 4 | 15.5 | | Ivan | 7 | 9 | | Aisha | 10 | 5 | | Zane | 13 | 7.5 | +--------+------+------+ 4 rows in set (0.00 sec) |
Als je records wilt filteren die aan een bepaalde voorwaarde voldoen, gebruik je WHERE. De rijen die niet aan de opgegeven voorwaarde voldoen, worden uit de resultaten verwijderd. De WHERE-clausule gebruikt de volgende syntaxis:
|
1 |
mysql> . . . WHERE column_name comparison_operator value |
Dit is een vergelijkingsoperator die definieert hoe de opgegeven kolom moet worden vergeleken met de waarde. Veelvoorkomende SQL-vergelijkingsoperators zijn onder andere:
|
Operator |
Gebruik |
|
= |
Gelijkheid |
|
!= |
Ongelijkheid |
|
< |
Kleiner dan |
|
> |
Groter dan |
|
<= |
Kleiner dan of gelijk aan |
|
>= |
Groter dan of gelijk aan |
|
BETWEEN |
Test of de waarde binnen het opgegeven bereik ligt. |
|
IN |
Test of de waarde van een rij is opgenomen in een set van opgegeven waarden. |
|
EXISTS |
Test of een rij bestaat |
|
LIKE |
Test of een waarde overeenkomt met de opgegeven tekenreeks |
|
IS NULL |
Test op null-waarden |
|
IS NOT NULL |
Test op alle waarden behalve NULL |
Als je de favoriete bestemming van Aisha wilde vinden, zou je de onderstaande query kunnen gebruiken:
|
1 |
mysql> SELECT destination FROM vacation WHERE name ='Aisha'; |
De query zal dan het volgende retourneren:
|
1 2 3 4 5 6 7 |
+-------------+ | destination | +-------------+ | Colorado | +-------------+ 1 rij in set (0.03 sec) |
SQL ondersteunt het gebruik van wildcard-tekens, die vooral nuttig zijn in WHERE-clausules. Percentagetekens ( %) geven nul of meer onbekende tekens aan, terwijl underscores ( _) een enkel onbekend teken aangeven. Deze zijn handig als u een specifieke vermelding in een tabel wilt vinden, maar niet zeker bent over de vermelding.
Als u bijvoorbeeld de favoriete bestemming van een vriend bent vergeten en alleen de letter wist waarmee deze begint, bijvoorbeeld “m”, kunt u de naam van de bestemming vinden met de volgende query:
|
1 |
mysql> SELECT destination FROM vacation WHERE destination LIKE 'm%'; |
De query zal het volgende retourneren:
|
1 2 3 4 5 6 7 8 |
+-------------+ | destination | +-------------+ | Malediven | | Mauritius | +-------------+ 2 rijen in set (0.04 sec) |
Wanneer u met databases werkt, kunt u kolommen of tabellen tegenkomen met relatief lange of moeilijk leesbare namen. In deze gevallen kunt u de namen leesbaarder maken door het trefwoord AS te gebruiken om een alias te maken. Aliassen die zijn gemaakt met AS zijn alleen geldig voor de duur van de query waarvoor ze zijn gemaakt:
|
1 2 3 4 5 6 7 8 9 10 11 |
mysql> SELECT name AS E, destination as D, activity as A FROM vacation; +--------+-----------+-------------------+ | E | D | A | +--------+-----------+-------------------+ | Austin | Malediven | skiën | | Ivan | Mauritius | paragliden | | Aisha | Colorado | berg beklimmen | | Zane | Bora Bora | vissen | +--------+-----------+-------------------+ 4 rijen in set (0.00 sec) |
Stap 3 — Inleiding tot aggregatiefuncties
Wanneer u met gegevens werkt, wilt u niet altijd de gegevens zelf zien. U wilt liever informatie over de gegevens. Door een SELECT-query uit te voeren, kunt u uw gegevens interpreteren of er berekeningen op uitvoeren met behulp van de SQL-syntaxis. Deze worden aggregatiefuncties genoemd.
De COUNT-functie telt en retourneert het aantal rijen dat aan een specifieke set criteria voldoet. Als u bijvoorbeeld wilt weten hoeveel vrienden liever naar de Malediven gaan, kunt u de volgende query gebruiken:
|
1 |
mysql> SELECT COUNT(destination) FROM vacation WHERE destination = 'Malediven'; |
De volgende resultaten worden geretourneerd:
|
1 2 3 4 5 6 7 |
+--------------------+ | COUNT(destination) | +--------------------+ | 1 | +--------------------+ 1 rij in set (0.06 sec) |
MIN wordt gebruikt om de kleinste waarde in een opgegeven kolom te vinden:
|
1 |
mysql> SELECT MIN(wins) FROM celebration; |
De query zal het volgende uitvoeren:
|
1 2 3 4 5 6 7 |
+-----------+ | MIN(wins) | +-----------+ | 4 | +-----------+ 1 rij in set (0.02 sec) |
MAX wordt gebruikt om de grootste numerieke waarde in een gegeven kolom te vinden:
|
1 |
mysql> SELECT MAX(wins) FROM celebration; |
De verwachte uitvoer is:
|
1 2 3 4 5 6 7 |
+-----------+ | MAX(wins) | +-----------+ | 13 | +-----------+ 1 rij in set (0.03 sec) |
Zowel de MIN als MAX-functies kunnen worden gebruikt op numerieke en alfabetische gegevens. Wanneer toegepast op een kolom met tekenreekswaarden, de MIN-functie de eerste waarde in alfabetische volgorde.
De MIN-functies retourneren de eerste waarde in alfabetische volgorde:
|
1 |
mysql> SELECT MIN(name) FROM celebration; |
Dit is wat de uitvoer zal zijn:
|
1 2 3 4 5 6 7 |
+-----------+ | MIN(name) | +-----------+ | Aisha | +-----------+ 1 rij in set (0.00 sec) |
De MAX-functie retourneert de laatste waarde in alfabetische volgorde:
|
1 |
mysql> SELECT MAX(name) FROM celebration; |
Dit is wat de uitvoer zal zijn:
|
1 2 3 4 5 6 7 |
+-----------+ | MAX(name) | +-----------+ | Zane | +-----------+ 1 rij in set (0.00 sec) |
Stap 4 — Query-uitvoer manipuleren
Een andere populaire clausule die wordt gebruikt, is de GROUP BY-clausule. Deze wordt gebruikt bij het uitvoeren van een aggregatiefunctie op één kolom, maar in relatie tot overeenkomende waarden in een andere:
|
1 |
mysql> SELECT COUNT(name), activity FROM vacation GROUP BY activity; |
De uitvoer zal zijn:
|
1 2 3 4 5 6 7 8 9 10 |
+-------------+-------------------+ | COUNT(name) | activity | +-------------+-------------------+ | 1 | skiën | | 1 | paragliden | | 1 | bergbeklimmen | | 1 | vissen | +-------------+-------------------+ 4 rijen in set (0.04 sec) |
Om queryresultaten te sorteren, gebruikt u de ORDER BY-clausule. Numerieke waarden worden standaard oplopend gesorteerd, terwijl tekstwaarden alfabetisch worden gesorteerd. De onderstaande query vermeldt de name en birthdate-kolommen, maar sorteert de resultaten op birthdate:
|
1 |
mysql> SELECT name, birthdate FROM vacation ORDER BY birthdate; |
De uitvoer is als volgt:
|
1 2 3 4 5 6 7 8 9 10 |
+--------+------------+ | name | birthdate | +--------+------------+ | Zane | 1996-01-01 | | Aisha | 1999-07-24 | | Austin | 2002-01-07 | | Ivan | 2010-12-18 | +--------+------------+ 4 rijen in set (0.04 sec) |
De uitvoer is in oplopende volgorde. Om in aflopende volgorde te sorteren, sluit u de query af met het woord DESC:
|
1 |
mysql> SELECT name, birthdate FROM vacation ORDER BY birthdate DESC; |
Bekijk de uitvoer:
|
1 2 3 4 5 6 7 8 9 10 |
+--------+------------+ | name | birthdate | +--------+------------+ | Ivan | 2010-12-18 | | Austin | 2002-01-07 | | Aisha | 1999-07-24 | | Zane | 1996-01-01 | +--------+------------+ 4 rijen in set (0.00 sec) |
De HAVING-clausule is aan SQL toegevoegd om vergelijkbare functionaliteit te bieden als de WHERE-clausule, terwijl deze ook compatibel is met aggregatiefuncties. Het verschil tussen deze twee clausules is dat WHERE dient om te verwijzen naar individuele records en HAVING verwijst naar groepsrecords. Daartoe moet de GROUP BY-clausule aanwezig zijn wanneer een HAVING-clausule wordt gebruikt:
|
1 |
mysql> SELECT COUNT(name), activity FROM vacation GROUP BY activity HAVING COUNT(name) >= 1; |
De query geeft als uitvoer:
|
1 2 3 4 5 6 7 8 |
+-------------+-------------------+ | COUNT(name) | activity | +-------------+-------------------+ | 1 | skiën | | 1 | paragliden | | 1 | bergbeklimmen | | 1 | vissen | +-------------+-------------------+ |
De COUNT is overal 1 omdat geen twee vrienden van dezelfde activiteit houden.
Stap 5 — Meerdere tabellen bevragen
De JOIN-clausule kan in een queryresultaat worden gebruikt om rijen uit twee of meer tabellen te combineren. Dit wordt bereikt door een gerelateerde kolom tussen de tabellen te zoeken en de uitvoer op de juiste manier te sorteren.
SELECT-instructies die een JOIN-clausule bevatten, volgen de onderstaande syntaxis:
|
1 2 3 |
mysql> SELECT table1.column1, table2.column2 mysql> FROM table1 mysql> JOIN table2 ON table1.related_column=table2.related_column; |
Als je voor elk van je vrienden een trofee wilde kopen voor hun overwinningen tijdens het zwemmen op hun verjaardagen, zou je een query kunnen maken die beide tabellen samenvoegt om je te helpen alle gewenste informatie te vinden met een enkele query:
|
1 2 3 |
mysql> SELECT celebration.name, celebration.wins, vacation.birthdate FROM celebration JOIN vacation ON celebration.name=vacation.name; |
De uitvoer is:
|
1 2 3 4 5 6 7 8 9 10 |
+--------+------+------------+ | name | wins | birthdate | +--------+------+------------+ | Austin | 4 | 2002-01-07 | | Ivan | 7 | 2010-12-18 | | Aisha | 10 | 1999-07-24 | | Zane | 13 | 1996-01-01 | +--------+------+------------+ 4 rows in set (0.00 sec) |
Dit is een inner JOIN-clausule. Dat komt omdat het alle records selecteert die overeenkomstige waarden in beide tabellen hebben en deze naar een resultaatset afdrukt. Records die niet overeenkomen met de query worden niet opgenomen. We kunnen een nieuwe rij in onze tabellen opnemen die niet overeenkomt met een invoer:
|
1 2 3 4 |
mysql> INSERT INTO celebration(name,wins,time) VALUES('Ella', '1', '120'); Query OK, 1 row affected (0.01 sec) |
|
1 2 3 4 |
mysql> INSERT INTO celebration(name,wins,time) VALUES('Ella', '1', '120'); Query OK, 1 row affected (0.01 sec) |
Voer vervolgens de SELECT-instructie opnieuw uit met de JOIN-clausule:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
mysql> SELECT celebration.name, celebration.wins, vacation.birthdate -> FROM celebration -> JOIN vacation ON celebration.name=vacation.name; +--------+------+------------+ | name | wins | birthdate | +--------+------+------------+ | Austin | 4 | 2002-01-07 | | Ivan | 7 | 2010-12-18 | | Aisha | 10 | 1999-07-24 | | Zane | 13 | 1996-01-01 | +--------+------+------------+ 4 rows in set (0.00 sec) |
Omdat de tabel celebration geen vermelding heeft voor Peter en de tabel vacation geen vermelding heeft voor Ella, zijn die records afwezig.
We kunnen alle records uit een van de tabellen retourneren door een outer JOIN-clausule te gebruiken. Dit kan een LEFT JOIN of een RIGHT JOIN zijn. Een LEFT JOIN retourneert alle records uit de linkertabel en alleen overeenkomende records uit de rechtertabel. De linkertabel in de context van outer joins is de tabel waarnaar wordt verwezen door de FROM-clausule, en de rechtertabel is elke tabel waarnaar wordt verwezen na de JOIN-instructie.
Voer de query opnieuw uit, maar gebruik een LEFT JOIN-clausule:
|
1 2 3 |
mysql> SELECT celebration.name, celebration.wins, vacation.birthdate FROM celebration LEFT JOIN vacation ON celebration.name=vacation.name; |
De opdracht retourneert alle records uit de linkertabel ( celebration) zelfs als deze geen overeenkomstige record in de rechtertabel heeft. Wanneer er geen overeenkomstige record in de rechtertabel is, wordt deze geretourneerd als NULL:
|
1 2 3 4 5 6 7 8 9 10 11 |
+--------+------+------------+ | name | wins | birthdate | +--------+------+------------+ | Austin | 4 | 2002-01-07 | | Ivan | 7 | 2010-12-18 | | Aisha | 10 | 1999-07-24 | | Zane | 13 | 1996-01-01 | | Ella | 1 | NULL | +--------+------+------------+ 5 rows in set (0.00 sec) |
Dit is nu de RIGHT JOIN-clausule:
|
1 2 3 |
mysql> SELECT celebration.name, celebration.wins, vacation.birthdate FROM celebration RIGHT JOIN vacation ON celebration.name=vacation.name; |
Alle waarden uit de rechtertabel worden geretourneerd (vacation). Omdat Peters birthdate is geregistreerd in de rechtertabel en niet in de linkertabel name en wins, zullen de kolommen NULL-waarden retourneren in die rijen:
|
1 2 3 4 5 6 7 8 9 10 11 |
+--------+------+------------+ | name | wins | birthdate | +--------+------+------------+ | Austin | 4 | 2002-01-07 | | Ivan | 7 | 2010-12-18 | | Aisha | 10 | 1999-07-24 | | Zane | 13 | 1996-01-01 | | NULL | NULL | 1991-05-03 | +--------+------+------------+ 5 rijen in set (0.01 sec) |
Je kunt de UNION-clausule gebruiken in plaats van JOIN om records uit meerdere tabellen op te vragen. De UNION-operator verschilt van de JOIN-clausule in die zin dat deze de resultaten van twee SELECT-instructies combineert in één kolom, in plaats van resultaten uit meerdere tabellen als unieke kolommen af te drukken met behulp van een enkele SELECT-instructie.
Je kunt deze query uitvoeren ter illustratie:
|
1 |
mysql> SELECT name FROM celebration UNION SELECT name FROM vacation; |
De query verwijdert dubbele vermeldingen. Dit is het standaardgedrag van de UNION-operator:
|
1 2 3 4 5 6 7 8 9 10 11 12 |
+--------+ | name | +--------+ | Austin | | Ivan | | Aisha | | Zane | | Ella | | Peter | +--------+ 6 rijen in set (0.00 sec) |
Om alle vermeldingen (plus duplicaten) te retourneren, gebruik je de UNION ALL-operator:
|
1 |
mysql> SELECT name FROM celebration UNION ALL SELECT name FROM vacation; |
Uitvoer:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
+--------+ | name | +--------+ | Austin | | Ivan | | Aisha | | Zane | | Ella | | Austin | | Ivan | | Aisha | | Zane | | Peter | +--------+ 10 rijen in set (0.00 sec) |
Subquery's zijn een andere methode om meerdere tabellen te bevragen. Subquery's zijn query's die zijn ingesloten in een andere query (ook wel interne of geneste query's genoemd). Deze zijn handig wanneer je de resultaten van een query wilt vergelijken met de resultaten van een afzonderlijke aggregatiefunctie.
We gebruiken het voorbeeld waarin we proberen te achterhalen welke vriend meer zwemtoernooien heeft gewonnen dan Ella. In plaats van op te vragen hoeveel wedstrijden Ella heeft gewonnen en vervolgens een andere query uit te voeren om te zien wie meer wedstrijden heeft gewonnen, kun je beide met een enkele query berekenen:
|
1 2 3 4 |
mysql> SELECT name, wins FROM celebration -> WHERE wins > ( -> SELECT wins FROM celebration WHERE name = 'Ella' -> ); |
De query retourneert:
|
1 2 3 4 5 6 7 8 9 10 |
+--------+------+ | name | wins | +--------+------+ | Austin | 4 | | Ivan | 7 | | Aisha | 10 | | Zane | 13 | +--------+------+ 4 rijen in set (0.06 sec) |
Als je je vrienden mee wilt nemen op een verrassingsvakantie, kun je een query gebruiken om te zien wie de meeste overwinningen heeft en hun bestemming te retourneren:
|
1 2 3 4 |
mysql> SELECT name, destination, activity, meal -> FROM vacation -> WHERE name = ( SELECT name FROM celebration -> WHERE wins = (SELECT MAX(wins) FROM celebration)); |
De query retourneert:
|
1 2 3 4 5 6 7 |
+------+-------------+----------+------+ | name | destination | activity | meal | +------+-------------+----------+------+ | Zane | Bora Bora | fishing | Tofu | +------+-------------+----------+------+ 1 rij in set (0.00 sec) |
Deze instructie bevat een subquery binnen een subquery.
Conclusie
Het genereren van query's is een van de meest voorkomende taken in databasebeheer. Er zijn verschillende databasebeheertools zoals phpMyAdmin en pgAdmin die je kunt gebruiken om met query's te werken en de resultaten ervan te visualiseren. De SELECT-instructie vanaf de opdrachtregel is echter de meest favoriete keuze vanwege het gebruiksgemak en de uitstekende controle.
Daarnaast zijn er veel handleidingen over databases die je kunt bekijken op onze blog:
- SQLite vs MySQL vs. PostgreSQL: Relationele databasebeheersystemen vergeleken
- Snelle oplossingen voor het repareren van beschadigde tabellen in MySQL: een handleiding
- MySQL installeren op Centos 7
- MySQL-gebruiker — Rechten aanmaken en verlenen
- Replicatie instellen in MySQL op Ubuntu
Veel computerplezier!
Reacties
Nog geen reacties. Wees de eerste.