MySQL-tutorial: een uitgebreide gids voor beginners

MySQL instellen

De installatie is eenvoudig. Download de juiste installer van de officiële website, afhankelijk van het besturingssysteem van je computer: macOS, Windows of Linux.

Installatie op macOS

Zodra je de MySQL-pakketinstaller hebt gedownload, volg je de instructies in de installatiewizard. Je kunt de standaardinstallatie volgen, maar je kunt ook onderdelen aanpassen via de knop "Customize".

MySQL Package Installer Wizard: Customize. Bron: MySQL

Na een geslaagde installatie van de nieuwe MySQL Server rond je de configuratiestappen af door het standaardtype versleuteling voor wachtwoorden te kiezen, het root-wachtwoord te definiëren en de MySQL-server bij het opstarten in of uit te schakelen.

Bij installatie via de pakketinstaller worden de bestanden geplaatst in een map binnen /usr/local die overeenkomt met de naam van de installatieversie en het platform.

Installatie op Windows

MySQL installeren op Windows is vrij eenvoudig. De aanbevolen methode is om de Windows Installer te downloaden en een specifieke versie van MySQL te laten installeren en configureren. Als je de standaardinstallatie gebruikt, start Windows MySQL automatisch als localhost.

Installatie op Linux

Linux ondersteunt verschillende manieren om MySQL te installeren. MySQL raadt aan om een van de distributies van Oracle te gebruiken; daarvoor zijn meerdere installatiemethoden beschikbaar, zoals je kunt vinden in de documentatie.

MySQL begrijpen

Voordat je met MySQL aan de slag gaat, is het de moeite waard om te bekijken hoe MySQL werkt. Laten we enkele kernbegrippen doornemen.

MySQL-architectuur

Net als veel andere populaire relationele databases is MySQL ontworpen volgens een client-serverarchitectuur.

In dit computermodel is een server bedoeld om data te hosten, databasepermissies en -configuraties te beheren en het grootste deel van de door de client gevraagde resources en services af te handelen.

In de meeste gangbare client-serverarchitecturen is er één centrale server en zijn er meerdere clients. Elke computer kan een server zijn als deze is ingericht om een service te leveren. Meestal zijn servers echter zeer krachtige en grote machines, omdat zij het best zijn uitgerust om een groot volume aan verzoeken en data te verwerken.

Clients daarentegen kunnen op elk type computer draaien.

Client-serverarchitectuur. Bron: DataCamp

In MySQL zijn deze twee componenten de MySQL-client en de MySQL-server.

Gegevenstypen

Gegevenstypen bepalen welke waarden een kolom kan bevatten. Het werkt als een soort metadata die SQL helpt te begrijpen welk type data in elke kolom wordt verwacht en hoe queries tegen een specifieke kolom moeten worden verwerkt.

MySQL ondersteunt de gebruikelijke SQL-gegevenstypen in drie hoofdcategorieën:

• Numerieke typen
• Tekenreeks-typen
• Datum- en tijdtypen

In de volgende tabellen vind je een overzicht van de belangrijkste gegevenstypen in MySQL.

Numerieke gegevenstypen

Datum- en tijdtypen

Tekenreeks-typen

Toegang tot MySQL

Zodra je MySQL op je computer hebt geïnstalleerd, kun je het gebruiken vanuit je terminal. Om MySQL te starten, log je in met je gebruikersnaam en het bijbehorende wachtwoord. In dit geval gebruiken we het root-account met het root-wachtwoord dat we tijdens de installatie hebben ingesteld. Omdat we inloggen op dezelfde machine waarop MySQL draait, hoeven we geen informatie op te geven in de host-parameter (-h):

> mysql -uroot -p

Als je nieuwe gebruikers wilt toevoegen, typ dan:

> CREATE USER 'username' IDENTIFIED BY 'password';

Zodra je een nieuwe gebruiker hebt aangemaakt, kun je met dit commando MySQL openen en verschijnt er een welkomstbericht, gevolgd door een mysql>-prompt:

> mysql -u username -p 
Welcome to the MySQL monitor.  Commands end with; or \g.
Your MySQL connection id is 25
Server version: 8.1.0 MySQL Community Server - GPL

Copyright (c) 2000, 2023, Oracle and/or its affiliates.

Oracle is a registered trademark of Oracle Corporation and/or its
affiliates. Other names may be trademarks of their respective
Owners.

Type 'help;' or '\h' for help. Type '\c' to clear the current input statement.

mysql>

Hoe maak je een MySQL-database

Een database aanmaken

Tijd om je eerste database in MySQL te maken. Voor deze tutorial willen we een database maken met de naam "datacamp_courses", die informatie bevat over enkele DataCamp-cursussen. De database wordt lokaal gehost.

Om een database te maken, gebruik je het volgende commando:

mysql> CREATE DATABASE datacamp_courses;

Om te controleren of de database is aangemaakt, typ je het volgende; er wordt dan een tabel weergegeven met alle beschikbare databases:

mysql> SHOW databases;
+--------------------+
| Database           |
+--------------------+
| datacamp_courses   |
| mysql              |
+--------------------+
5 rows in set (0,00 sec)

Je kunt nu je gloednieuwe database openen.

mysql> USE datacamp_courses;
Database changed

Een tabel aanmaken

Tot nu toe heb je je eerste database aangemaakt. Maar hij is nog leeg. Nu gaan we de eerste tabel van de database maken. We willen een tabel maken met de naam 'courses', met informatie over verschillende cursussen uit de DataCamp-catalogus.

Het is tijd om je eerste tabel te maken in de database "datacamp_courses". We willen een tabel met informatie over enkele cursussen in de DataCamp-catalogus.

De primaire sleutel van de tabel moet course_id zijn (let op: alleen deze is vet) en het gegevenstype moet een integer zijn. Een primaire sleutel is een constraint die afdwingt dat de kolomwaarden niet null en uniek zijn. Hiermee kun je een specifieke instantie of een set instanties in de tabel uniek identificeren.

De overige kolommen geven informatie over de cursusnaam, de docent, het onderwerp van de cursus en de url.

Om de eerste tabel van de database "datatacamp_courses" te maken, gebruik je het volgende commando:

mysql> CREATE TABLE courses (
  course_id int NOT NULL,
  course_name varchar(250) NOT NULL,
  instructor_name varchar(250) NOT NULL,
  technology varchar(50) NOT NULL,
  topic varchar(50) NOT NULL,
  PRIMARY KEY (course_id)
);

Basis-SQL-queries

Je hebt je eerste database en je eerste tabel. Top! Nu is het tijd om wat data aan de tabel toe te voegen.

Laten we wat rijen toevoegen met populaire cursussen uit onze catalogus met de INSERT-instructie. De volgende code doet het werk.

INSERT INTO 
    courses (course_id, course_name, instructor_name, technology, topic) VALUES 
    (1, 'Introduction to SQL', 'Izzy Weber', 'SQL','Data Manipulation'), 
    (2, 'Database Design', 'Lis Sulmont', 'SQL', 'Data Engineering'), 
    (3, 'Data Manipulation with pandas', 'Richie Cotton', 'R','Programming'),
    (4, 'Generative AI Concepts', 'Daniel Tedesco', 'Theory', 'AI & Machine Learning');

Om te controleren of de rijen correct zijn toegevoegd, bekijken we alle rijen in de tabel met de SELECT-instructie:

SELECT * FROM courses;
+-----------+-------------------------------+-----------------+------------+-----------------------+
| course_id | course_name                   | instructor_name | technology | topic                 |
+-----------+-------------------------------+-----------------+------------+-----------------------+
|         1 | Introduction to SQL           | Izzy Weber      | SQL        | Data Manipulation     |
|         2 | Database Design               | Lis Sulmont     | SQL        | Data Engineering      |
|         3 | Data Manipulation with pandas | Richie Cotton   | R          | Programming           |
|         4 | Generative AI Concepts        | Daniel Tedesco  | Theory     | AI & Machine Learning |
+-----------+-------------------------------+-----------------+------------+-----------------------+
4 rows in set (0,00 sec)

Je hebt misschien gemerkt dat er een fout zit in de data die we zojuist hebben toegevoegd. De technology van de cursus Data Manipulation with pandas is Python, niet R. Laten we de fout herstellen met de UPDATE-instructie in combinatie met de WHERE-clausule om de te updaten rij te specificeren

UPDATE courses SET technology = 'Python' WHERE course_id = 3;

SELECT * FROM courses;
+-----------+-------------------------------+-----------------+------------+-----------------------+
| course_id | course_name                   | instructor_name | technology | topic                 |
+-----------+-------------------------------+-----------------+------------+-----------------------+
|         1 | Introduction to SQL           | Izzy Weber      | SQL        | Data Manipulation     |
|         2 | Database Design               | Lis Sulmont     | SQL        | Data Engineering      |
|         3 | Data Manipulation with pandas | Richie Cotton   | Python     | Programming           |
|         4 | Generative AI Concepts        | Daniel Tedesco  | Theory     | AI & Machine Learning |
+-----------+-------------------------------+-----------------+------------+-----------------------+
4 rows in set (0,00 sec)

Tot slot wil je misschien één van de records in je tabel verwijderen. Laten we bijvoorbeeld de cursus Generative AI Concepts verwijderen:

DELETE from courses WHERE course_name = 'Generative AI Concepts';

SELECT * FROM courses;
+-----------+-------------------------------+-----------------+------------+-------------------+
| course_id | course_name                   | instructor_name | technology | topic             |
+-----------+-------------------------------+-----------------+------------+-------------------+
|         1 | Introduction to SQL           | Izzy Weber      | SQL        | Data Manipulation |
|         2 | Database Design               | Lis Sulmont     | SQL        | Data Engineering  |
|         3 | Data Manipulation with pandas | Richie Cotton   | Python     | Programming       |
+-----------+-------------------------------+-----------------+------------+-------------------+
3 rows in set (0,00 sec)

Geavanceerde onderwerpen

Indexeren

Standaard begint MySQL, wanneer het rijen moet zoeken, bij de eerste en leest vervolgens van kop tot staart. Dit gedrag kan problematisch zijn wanneer je databases miljoenen rijen bevatten, omdat het proces dan erg traag kan zijn.

Een goede manier om het zoeken in je tabellen te versnellen is door een index te maken. Een index is een onderdeel van je tabellen dat MySQL gebruikt om rijen met specifieke kolommen sneller op te halen.

Laten we een index maken in onze coursetabel met de naam "idx_course" op de kolom "course_id".

CREATE INDEX idx_course
ON courses (course_id);

Joins

Tot nu toe hebben we alleen met de coursetabel gewerkt. Maar je benut pas echt het volledige potentieel van relationele databases, zoals MySQL, wanneer je met meerdere tabellen tegelijk werkt.

De magische tool om meerdere tabellen te combineren is de JOIN-operatie. Stel dat we een tweede tabel in onze database hebben met de naam 'instructors" die basisinformatie bevat over de DataCamp-docenten. Het volgende script maakt de tabel en voegt enkele (fictieve) rijen toe:

mysql> CREATE TABLE instructors (
  instructor_id int NOT NULL,
  instructor_name varchar(250) NOT NULL,
  role varchar(500) NOT NULL,
  number_courses int NOT NULL,
  PRIMARY KEY (instructor_id)
);

INSERT INTO 
    instructors (instructor_id, instructor_name, role, number_courses) VALUES 
    (1, 'Lis Sulmont', 'Data Scientist', 4),
    (2, 'Daniel Tedesco', 'Business Analyst', 1),
    (3, 'Richie Cotton', 'Data Evangelist',5),
    (4, 'Izzy Weber', 'Data Engineer', 2), 
    (5, 'James Chapman', 'Data Analyst',3);

Stel dat je de twee tabellen wilt samenvoegen om zowel de informatie over de cursussen als de gegevens van de docent te krijgen. We gebruiken een INNER JOIN om alleen de informatie op te halen over de cursussen die in de coursetabel voorkomen. De gemeenschappelijke kolom voor de join is "instructor_name".

mysql> SELECT * FROM courses
    -> INNER JOIN instructors
    -> ON courses.instructor_name = instructors.instructor_name;
+-----------+-------------------------------+-----------------+------------+-------------------+---------------+-----------------+-----------------+----------------+
| course_id | course_name                   | instructor_name | technology | topic             | instructor_id | instructor_name | role            | number_courses |
+-----------+-------------------------------+-----------------+------------+-------------------+---------------+-----------------+-----------------+----------------+
|         2 | Database Design               | Lis Sulmont     | SQL        | Data Engineering  |             1 | Lis Sulmont     | Data Scientist  |              4 |
|         3 | Data Manipulation with pandas | Richie Cotton   | Python     | Programming       |             3 | Richie Cotton   | Data Evangelist |              5 |
|         1 | Introduction to SQL           | Izzy Weber      | SQL        | Data Manipulation |             4 | Izzy Weber      | Data Engineer   |              2 |
+-----------+-------------------------------+-----------------+------------+-------------------+---------------+-----------------+-----------------+----------------+
3 rows in set (0,00 sec)

Dit is slechts één type join, maar er zijn er meer die net zo nuttig zijn, afhankelijk van je usecase. Onze cursus Joining Data in SQL en cheat sheet over JOINS helpen je op weg.

Best practices voor MySQL

Beveiligingsmaatregelen

Moderne databases kunnen tabellen met miljoenen rijen opslaan. Met zoveel data en applicaties die erop draaien, is het cruciaal om deze data veilig te houden.

Databases lopen algemene risico's, waaronder slecht beheer van toegangsrechten, zwakke wachtwoorden en SQL-injecties. Om deze bedreigingen en zwaktes aan te pakken, kun je diverse strategieën en maatregelen toepassen, waaronder toegangsrechten configureren per gebruiker, triggers bouwen in SQL-servers en versleutelingsmethoden implementeren. Een goed startpunt voor SQL-beveiliging is onze cursus Database Design.

Prestatie-optimalisatie

Naarmate je vordert in je SQL-reis, zul je het belang van performance steeds beter zien. Een SQL-query kun je op verschillende manieren schrijven. Ze werken allemaal, maar de ene is efficiënter dan de andere.

Er zijn veel strategieën en trucs om de performance van je SQL-code te verbeteren, waaronder subquery's en SQL-clausules zoals WHERE, HAVING en DISTINCT.

Maar efficiëntie is niet alleen technisch; het gaat ook om structuur en leesbaarheid. Met kleine aanpassingen in hoe je SQL schrijft, zoals het gebruik van aliassen en commentaar, kun je een groot verschil maken voor jezelf en de rest van je team.

Wil je meer leren over het optimaliseren van SQL-prestaties? Bekijk dan onze cursus Improving Query Performance in SQL Server

Conclusie

Gefeliciteerd dat je het einde van deze MySQL-tutorial hebt bereikt. We hopen dat je hebt genoten van deze introductie tot MySQL en de mogelijkheden ervan. Als je geïnteresseerd bent in databasemanagement, is MySQL leren een slimme zet.

Maar dit is nog maar het begin van je reis. Wil je meer leren over MySQL en SQL in het algemeen, dan ben je bij Datacamp aan het juiste adres. Hier zijn enkele bronnen om je op weg te helpen:

• Managing Databases in SQL Course
• Database Design Course
• MySQL in Python Tutorial: Getting Started
• SQL Server Developer Career Track
• SQL Server, PostgreSQL, MySQL... What’s the difference? Where do I start?