Module: MySQL

Module: MySQL

Inleiding

In deze module ga je kennis maken met MySQL. MySQL is een relational database management system (RDBMS). Het wordt veel gebruikt voor opslag van gegevens van websites. Je leert waarom databases handig zijn, hoe je een database maakt, en gebruikt in een website m.b.v. PHP. Voor het beheer gebruiken we het programma HeidiSQL. Bij alle voorbeelden laten we ook de SQL regel zien die je hiervoor kunt gebruiken.

Waarom een Database

De meeste van jullie hebben waarschijnlijk wel eens een tabel gemaakt in Excel of een ander spreadsheet programma. Dit soort programma's is handig als je gegevens wilt verzamelen en sorteren. Een database doet in principe hetzelfde, maar heeft een aantal voordelen.
Een database is bijvoorbeeld gemakkelijk te koppelen aan een programeer taal zoals PHP. Waardoor je gemakkelijk gegevens kunt presenteren via een website. Daarnaast is een database gemaakt om grote hoeveelheden data te bevatten, miljoenen regels. Doordat een database, zoals MySQL, gebruik maakt van Structured Query Language (SQL) is het eenvoudig om gegevens aan de database toe te voegen, te updaten en te doorzoeken.

Data toevoegen aan een SQL database:
INSERT INTO table_name (column1, column2, column3, ...) VALUES (value1, value2, value3, ...);
Data updaten in een SQL database:
UPDATE table_name SET column1 = value1, column2 = value2, ... WHERE condition;
Data zoeken in een SQL database:
SELECT column1, column2, ... FROM table_name WHERE condition;

Databases zijn ook zo ontworpen dat er veel mensen tegelijk mee kunnen werken. De database van google verwerken bijvoorbeeld 5,4 miljard verzoeken per dag. Tot slot is een voordeel van een relationele database dat je meerdere tabellen aan elkaar kunt koppelen. Zo kun je gemakkelijk extra gegevens opslaan en later aan elkaar koppelen.

De Database

Als je een database gaat ontwerpen begin je met het aanmaken van de database zelf. De database zelf is niet meer dan een map waarin je alle onderdelen van de database verzameld. Bij het maken van de database kies je de naam voor deze database. Een MySQL database kan de volgende onderdelen bevatten:

Tabel

Een MySQL-tabel is een georganiseerde verzameling gegevens die in rijen en kolommen is opgeslagen. Elke rij in een tabel vertegenwoordigt een afzonderlijk record en elke kolom vertegenwoordigt een veld van gegevens. Je kunt tabellen maken met behulp van de CREATE TABLE-opdracht en de gegevens in de tabel manipuleren met behulp van SQL-instructies zoals SELECT, INSERT, UPDATE en DELETE. In een volgend hoofdstuk gaan we dieper in op tabellen.

View

Een MySQL view is een virtuele tabel die is gebaseerd op het resultaat van een SQL-instructie. Een view bevat rijen en kolommen, net als een echte tabel. De velden in een view zijn velden van één of meer echte tabellen in de database. Je kunt SQL-instructies en functies aan een view toevoegen en de gegevens presenteren alsof ze afkomstig zijn van één enkele tabel. Een view wordt gemaakt met de CREATE VIEW-opdracht en kan worden bijgewerkt met de CREATE OR REPLACE VIEW-opdracht. Een view kan worden verwijderd met de DROP VIEW-opdracht.

Stored Procedure

Een MySQL Stored Procedure is een set van vooraf geschreven SQL-commando’s die kunnen worden opgeslagen en hergebruikt wanneer dat nodig is. Het is een databaseobject dat een specifieke taak uitvoert en kan worden aangeroepen door andere programma’s of scripts. Opgeslagen procedures worden voornamelijk gebruikt om complexe queries te vereenvoudigen en de prestaties van database-applicaties te verbeteren door de hoeveelheid gegevens die over het netwerk worden verzonden te verminderen. Om een Stored Procedure in MySQL te maken, kun je de CREATE PROCEDURE-opdracht gebruiken, gevolgd door de naam van de procedure en de SQL-commando’s die de procedure vormen. De procedure kan vervolgens worden aangeroepen met behulp van de CALL-opdracht, gevolgd door de naam van de procedure en eventuele vereiste parameters.

Stored Function

Een MySQL Stored Function is een speciaal soort opgeslagen programma dat een enkele waarde retourneert. Meestal gebruik je opgeslagen functies om veelvoorkomende formules of bedrijfsregels te groeperen die herbruikbaar zijn tussen SQL-statements of opgeslagen programma’s. In tegenstelling tot een opgeslagen procedure, kun je een opgeslagen functie gebruiken in SQL-statements waar een expressie wordt gebruikt. Dit helpt de leesbaarheid en onderhoudbaarheid van de procedurele code te verbeteren. Om een opgeslagen functie te maken in MySQL, gebruik je de CREATE FUNCTION-opdracht.

Trigger

Een trigger in MySQL is een set instructies die automatisch worden uitgevoerd of “geactiveerd” als reactie op een specifieke gebeurtenis, zoals een INSERT-, UPDATE- of DELETE-instructie. Triggers stellen je in staat om extra acties uit te voeren, zoals gegevensvalidatie of aangepaste gegevensverwerking, vóór of na de gebeurtenis die de trigger activeert. De syntaxis voor het maken van een trigger in MySQL is: CREATE TRIGGER trigger_name {BEFORE | AFTER} event ON table_name [FOR EACH ROW] BEGIN -- trigger body END; Waarbij trigger_name de naam van de trigger is, event de gebeurtenis die de trigger activeert (bijvoorbeeld INSERT, UPDATE, DELETE), table_name de naam van de tabel waaraan de trigger is gekoppeld en FOR EACH ROW aangeeft dat de trigger één keer moet worden uitgevoerd voor elke rij die wordt beïnvloed door de gebeurtenis die de trigger activeert.

Event

Een MySQL event is een taak die volgens een bepaald schema wordt uitgevoerd. MySQL events zijn benoemde objecten die één of meer SQL-instructies bevatten. Ze worden opgeslagen in de database en uitgevoerd op één of meer intervallen.
De MySQL Event Scheduler beheert het schema en de uitvoering van events. MySQL events kunnen erg handig zijn in veel gevallen, zoals het optimaliseren van databasetabellen, het opruimen van logboeken, het archiveren van gegevens of het genereren van complexe rapporten tijdens daluren. Om een nieuw event te maken in MySQL, gebruik je de CREATE EVENT-opdracht.

Tabellen

Een tabel bevat kolommen en rijen. Kolommen in een MySQL-tabel worden gebruikt om gegevens op te slaan. Elke kolom in een tabel heeft een naam en een datatype dat bepaalt welk type gegevens erin kan worden opgeslagen. Bijvoorbeeld, een kolom met de naam “leeftijd” kan het datatype INT hebben om gehele getallen op te slaan die de leeftijd van personen vertegenwoordigen. Elke rij in een tabel vertegenwoordigt één record en elke kolom in die rij bevat een specifiek stukje informatie over dat record. Bijvoorbeeld, als je een tabel hebt met informatie over werknemers, kan elke rij informatie bevatten over één werknemer en elke kolom kan informatie bevatten zoals de naam, het adres, de functie en het salaris van die werknemer.

 

 

Kolommen

Kolommen helpen bij het organiseren van gegevens in een tabel en maken het gemakkelijker om specifieke informatie op te zoeken en te analyseren.
Om een kolom te definiëren in een MySQL-tabel, moet je de volgende informatie opgeven:

  • Naam: De naam van de kolom. Dit is hoe je naar de kolom zult verwijzen in je SQL-opdrachten.
  • Datatype: Het datatype van de kolom. Dit bepaalt welk type gegevens erin kan worden opgeslagen.
  • Lengte/waarden: Voor sommige datatypen moet je ook de maximale lengte of het aantal waarden opgeven dat in de kolom kan worden opgeslagen.
  • Attributen: Je kunt extra attributen opgeven voor de kolom, zoals of deze NULL-waarden accepteert of niet.
  • Index: Je kunt aangeven of de kolom moet worden geïndexeerd voor snellere zoekopdrachten.
  • Auto_increment: Voor numerieke kolommen kun je aangeven of de waarde automatisch moet worden verhoogd bij elke nieuwe rij die wordt ingevoegd.
  • Standaard: Je kunt een standaardwaarde opgeven voor de kolom die wordt gebruikt wanneer er geen waarde wordt opgegeven bij het invoegen van een nieuwe rij.

Hier is een voorbeeld van hoe je een kolom kunt definiëren in een CREATE TABLE-opdracht:

CREATE TABLE werknemers (
    id INT AUTO_INCREMENT PRIMARY KEY,
    voornaam VARCHAR(255) NOT NULL,
    achternaam VARCHAR(255) NOT NULL,
    geboortedatum DATE
);
In dit voorbeeld definiëren we een tabel met vier kolommen: “id”, “voornaam”, “achternaam” en “geboortedatum”. De “id”-kolom is van het datatype INT en wordt automatisch verhoogd bij elke nieuwe rij die wordt ingevoegd. Het is ook de PRIMARY KEY van de tabel. De “voornaam” en “achternaam” kolommen zijn van het datatype VARCHAR met een maximale lengte van 255 tekens en kunnen geen NULL-waarden bevatten. De “geboortedatum” kolom is van het datatype DATE en heeft geen extra attributen.

 

Datatype

In MySQL zijn er drie hoofdtypen gegevens: tekenreeks, numeriek en datum en tijd.

Tekenreekstypen zijn onder andere:

  • CHAR(size): een vaste lengte string (kan letters, cijfers en speciale tekens bevatten).
  • VARCHAR(size): een variabele lengte string (kan letters, cijfers en speciale tekens bevatten).
  • TINYTEXT: houdt een string met een maximale lengte van 255 tekens.
  • TEXT(size): houdt een string met een maximale lengte van 65.535 bytes.
  • MEDIUMTEXT: houdt een string met een maximale lengte van 16.777.215 tekens.
  • LONGTEXT: houdt een string met een maximale lengte van 4.294.967.295 tekens.

Numerieke typen zijn onder andere:

  • BIT(size): een bit-waarde type.
  • TINYINT(size): een zeer klein geheel getal.
  • BOOL: nul wordt beschouwd als onwaar, niet-nulwaarden worden beschouwd als waar.
  • SMALLINT(size): een klein geheel getal.
  • MEDIUMINT(size): een middelgroot geheel getal.
  • INT(size): een normaal geheel getal.
  • BIGINT(size): een groot geheel getal.

Datum- en tijdtypen zijn onder andere:

  • DATE: datum (YYYY-MM-DD).
  • DATETIME(fsp): combinatie van datum en tijd (YYYY-MM-DD hh:mm:ss).
  • TIMESTAMP(fsp): combinatie van datum en tijd (YYYY-MM-DD hh:mm:ss).
  • TIME(fsp): tijd (hh:mm:ss).
  • YEAR: jaar (YYYY).

Dit is slechts een selectie van de beschikbare datatypen in MySQL. Voor meer informatie over de verschillende datatypen en hun eigenschappen kun je de MySQL-documentatie raadplegen. https://www.w3schools.com/sql/sql_datatypes.asp

Attributen

Bij het maken van een MySQL-kolom kun je verschillende attributen opgeven om het gedrag van de kolom te bepalen. Hier zijn enkele veelgebruikte attributen:

  • NOT NULL: Dit attribuut geeft aan dat de kolom geen NULL-waarden mag bevatten. Als je probeert een NULL-waarde in te voegen in een kolom met het NOT NULL-attribuut, zal MySQL een foutmelding geven.
  • DEFAULT: Met dit attribuut kun je een standaardwaarde opgeven voor de kolom. Als je geen waarde opgeeft bij het invoegen van een nieuwe rij, zal MySQL de standaardwaarde gebruiken.
  • UNSIGNED: Dit attribuut kan worden gebruikt met numerieke datatypen om aan te geven dat de kolom alleen positieve waarden en nul mag bevatten.
  • AUTO_INCREMENT: Dit attribuut kan worden gebruikt met numerieke datatypen om aan te geven dat de waarde van de kolom automatisch moet worden verhoogd bij elke nieuwe rij die wordt ingevoegd.

Je kunt meerdere attributen opgeven voor een kolom door ze te scheiden met spaties. Bijvoorbeeld:

CREATE TABLE werknemers (
    id INT NOT NULL AUTO_INCREMENT PRIMARY KEY,
    voornaam VARCHAR(255) NOT NULL,
    achternaam VARCHAR(255) NOT NULL,
    geboortedatum DATE DEFAULT '2000-01-01'
);
In dit voorbeeld definiëren we een tabel met vier kolommen. De “id”-kolom heeft de attributen NOT NULL, AUTO_INCREMENT en PRIMARY KEY. De “voornaam” en “achternaam” kolommen hebben het NOT NULL-attribuut. De “geboortedatum” kolom heeft het DEFAULT-attribuut met een standaardwaarde van ‘2000-01-01’.
 

Indexen

In een MySQL-database tabel kunnen verschillende soorten indexen worden gebruikt om de prestaties van zoekopdrachten te verbeteren. Indexen worden gebruikt om snel rijen met specifieke kolomwaarden te vinden. Zonder een index moet MySQL beginnen met de eerste rij en vervolgens door de hele tabel lezen om de relevante rijen te vinden. Hoe groter de tabel, hoe meer dit kost.

De meest voorkomende indexen zijn PRIMARY KEY, UNIQUE, INDEX en FULLTEXT.

  • Een PRIMARY KEY index is een unieke identificatie voor elk record in een tabel. Primary keys moeten unieke waarden bevatten en kunnen geen NULL-waarden bevatten. Een tabel kan slechts één primary key hebben en deze kan bestaan uit één of meerdere kolommen.
  • Een UNIQUE index is een constraint die ervoor zorgt dat alle waarden in een kolom uniek zijn. Dit betekent dat er geen dubbele waarden in de kolom mogen voorkomen. Een tabel kan meerdere UNIQUE KEYs hebben.
  • Een INDEX is een normale niet-unieke index. Niet-unieke waarden voor de index zijn toegestaan, dus de index kan rijen bevatten met identieke waarden in alle kolommen van de index. Deze indexen leggen geen beperkingen op aan uw gegevens, dus ze worden alleen gebruikt voor toegang - om snel bepaalde bereiken van records te bereiken zonder alle records te scannen.
  • Een FULLTEXT index is anders dan alle bovenstaande en hun gedrag verschilt aanzienlijk tussen databasesystemen. FULLTEXT-indexen zijn alleen nuttig voor volledige tekstzoekopdrachten die worden uitgevoerd met de MATCH () / AGAINST ()-clausule

De meeste MySQL-indexen (PRIMARY KEY, UNIQUE, INDEX en FULLTEXT) worden opgeslagen in B-trees.
Een B-tree is een soort zoekboom die wordt gebruikt om gegevens op een georganiseerde manier op te slaan en snel te kunnen zoeken. In tegenstelling tot een binaire zoekboom, waarbij elke knoop maximaal twee kinderen heeft, kan een B-tree knooppunten hebben met meer dan twee kinderen. Dit maakt het mogelijk om grote hoeveelheden gegevens efficiënt op te slaan en te doorzoeken.
Je kunt het zien als een grote boom met veel takken en bladeren. De takken zijn de knooppunten en de bladeren zijn de gegevens die worden opgeslagen. Wanneer je naar een specifiek stukje informatie zoekt, volg je de takken van de boom totdat je bij het juiste blad aankomt. Door de manier waarop de boom is georganiseerd, kan dit snel en efficiënt gebeuren.

Forein Keys

Een FOREIGN KEY in MySQL is een manier om relaties tussen tabellen in een database aan te geven. Het is een veld (of een verzameling velden) in één tabel die verwijst naar de PRIMARY KEY van een andere tabel. Het doel van de FOREIGN KEY is om te zorgen voor referentiële integriteit van de gegevens, wat betekent dat de relaties tussen tabellen worden gehandhaafd en dat er geen ongeldige gegevens worden ingevoegd.

Stel bijvoorbeeld dat je twee tabellen hebt: een “werknemers” tabel en een “afdelingen” tabel. Elke werknemer werkt op een bepaalde afdeling en elke afdeling heeft meerdere werknemers. Je kunt deze relatie aangeven door een FOREIGN KEY in de “werknemers” tabel die verwijst naar de PRIMARY KEY van de “afdelingen” tabel.

CREATE TABLE afdelingen (
    id INT AUTO_INCREMENT PRIMARY KEY,
    naam VARCHAR(255) NOT NULL
);

CREATE TABLE werknemers (
    id INT AUTO_INCREMENT PRIMARY KEY,
    voornaam VARCHAR(255) NOT NULL,
    achternaam VARCHAR(255) NOT NULL,
    afdeling_id INT,
    FOREIGN KEY (afdeling_id) REFERENCES afdelingen(id)
);
In dit voorbeeld hebben we twee tabellen gemaakt: “afdelingen” en “werknemers”. De “afdelingen” tabel heeft een PRIMARY KEY “id” en een kolom “naam”. De “werknemers” tabel heeft een PRIMARY KEY “id”, kolommen “voornaam” en “achternaam”, en een FOREIGN KEY “afdeling_id” die verwijst naar de PRIMARY KEY van de “afdelingen” tabel.

Met deze FOREIGN KEY kunnen we ervoor zorgen dat elke werknemer is toegewezen aan een bestaande afdeling. Als we proberen een werknemer toe te voegen met een afdeling_id die niet bestaat in de “afdelingen” tabel, zal MySQL een foutmelding geven.

FOREIGN KEYs helpen dus om de integriteit van de gegevens in onze database te behouden en om ervoor te zorgen dat relaties tussen tabellen correct worden gehandhaafd.
 

Check constraints

Een CHECK constraint in MySQL wordt gebruikt om het waardebereik te beperken dat in een kolom kan worden geplaatst. Als je een CHECK constraint op een kolom definieert, zal het alleen bepaalde waarden voor deze kolom toestaan. Als je een CHECK constraint op een tabel definieert, kan het de waarden in bepaalde kolommen beperken op basis van waarden in andere kolommen in de rij.

Bijvoorbeeld, stel dat je een tabel hebt met informatie over werknemers en je wilt ervoor zorgen dat de leeftijd van elke werknemer minimaal 18 jaar is. Je kunt een CHECK constraint op de “leeftijd” kolom definiëren om dit te bereiken:

CREATE TABLE werknemers (
    id INT AUTO_INCREMENT PRIMARY KEY,
    voornaam VARCHAR(255) NOT NULL,
    achternaam VARCHAR(255) NOT NULL,
    leeftijd INT,
    CHECK (leeftijd >= 18)
);
In dit voorbeeld hebben we een CHECK constraint gedefinieerd op de “leeftijd” kolom die ervoor zorgt dat de waarde van de kolom altijd groter dan of gelijk aan 18 moet zijn. Als we proberen een werknemer toe te voegen met een leeftijd kleiner dan 18, zal MySQL een foutmelding geven.

CHECK constraints helpen dus om de integriteit van de gegevens in onze database te behouden en om ervoor te zorgen dat alleen geldige gegevens worden ingevoegd.

Database beheren met HeidiSQL

Om wijzigingen aan te brengen in een database met HeidiSQL moeten we eerst verbinding maken. In dit voorbeeld gaan we er van uit dat de database op de lokale machine draait m.b.v. bijv. XAMPP.
Start het programma HeidiSQL. Je zie nu de sessionmanager.

Klik op nieuw links onder in het scherm. En vul de naam "localhost" in. Vul nu de verbindinggegevens in aan de rechterkant. Als je XAMPP gebruikt staan deze gegevens waarschijnlijk al goed.
Klik daarna op de knop "Openen".

Je bent nu verbonden.

Nieuwe database

Bij het maken van een nieuwe database moet je eerst goed nadenken over de structuur. Dit is hetzelfde als het verzinnen van de kolommen in een spreadsheet.
Laten we als voorbeeld een school nemen. De administratie wil de gegevens van de leerlingen opslaan in een database.
We gaan eerst op zoek naar welke gegevens we willen vastleggen.
In een gesprek met de administratie blijkt het om de volgende gegevens te gaan:

  • Leerlingnummer
  • Voornaam
  • Tussenvoegsels
  • Achternaam
  • Geboorte datum
  • Stamgroep

Naast deze gegevens wil de administratie ook opslaan in welke lesgroepen een leerling zit.

We starten met het maken van een nieuwe database met de naam "administratie".

Om een database te maken klik je met de rechtermuisknop op de naam van de mysql-server, in ons geval localhost.

 

SQL commando:
CREATE DATABASE administratie;

In deze database maken we een nieuwe tabel die we "leerlingen" noemen.

In deze tabel gaan we meteen kolomen maken om de data in op te slaan. Bij het aanmaken van de kolommen moet ook de eigenschappen van de kolommen aangeven.
Bij een kolom kun je de volgende eigenschappen meegeven:

  • Naam: Geef kolomen altijd een naam die aangeeft wat je in de kolom opslaat. Het is ook verstandig om in de kolomnaam een deel van de tabelnaam te verwerken. Als je meerdere tabellen aan elkaar gaat verbinden is het handig als je aan de kolomnaam ook kunt zien in welke tabel deze zit.
  • Datatype: Hier geef je aan wat voor soort informatie je gaat opslaan. Zie ... voor de verschillende datatypen.
  • Lengte: Dit veld is niet voor ieder type beschikbaar. Hier geef je de maximale lengte aan die het veld kan hebben. Als je bijv. bij een varchar een lengte van 10 geeft, dan kunnen er maximaal 10 tekens in het veld worden opgeslagen.
  • Unsigned: Mag er een min-teken voor het getal. Oftewel kan de waarde negatief (signed) of alleen positief(unsigned) zijn. Als je unsigned kiest wordt de maximale positieve waarde vergroot.
  • NULL toestaan: Mag de kolom leeg zijn (NULL).
  • Met nullen aanvullen: Aanvullen met nullen. Deze functie gaat in de toekomst verdwijnen.
  • Standaard: Hier kun je aangeven wat de standaard waarde moet zijn als je de kolom niet zelf vult. Ook kun je hier AUTO_INCREMENT aangeven bij een getal. AUTO_INCREMENT geeft ieder nieuwe regel automatisch een regelnummer. Dit is handig bij bijvoorbeeld selecteren en verwijderen van regels, hierdoor heb je altijd een uniek regelnummer.

Tot slot kun je bij kolommen aangeven of deze een sleutel(key) moet krijgen. De volgende sleutels zijn beschikbaar:

  • PRIMARY: Een tabel kan maar één primaire sleutel hebben. Het primaire sleutel veld heeft een unieke waarde in de tabel. Hiermee kun je de regel identificeren.
  • UNIQUE: Zorgt ervoor dat er in deze kolom geen dubbele waarden voor mogen komen.
  • KEY: Voegt een index toe aan een kolom. Als je een kolom veel gebruikt om in te zoeken, dan verhoogt een index de zoeksnelheid.
  • FULLTEXT: Voegt een index toe aan een tekst kolom. Als je een kolom veel gebruikt om in te zoeken, dan verhoogt een index de zoeksnelheid.

Een index kun je toevoegen door met de rechtermuisknop op een kolom te klikken en te kiezen voor "Maak nieuwe index".

INFO:
Je kun een index vergelijken met een index achter in een boek. Als voorbeeld gaan we een lindenboom opzoeken in een dik boek over planten. Je kunt bladzijde voor bladzijde door een boek bladeren totdat je de lindenboom tegenkomt. Dit duur lang. Als je de index achter in het boek gebruikt gaat het veel sneller. Zoek in de alfabetische lijst naar lindenboom en achter de naam staat het paginanummer waar je de lindenboom kunt vinden. Indexen in een database werken op eenzelfde manier.

 

Maak de kolommen zoals in de bovenstaande afbeelding.

SQL commando:

CREATE TABLE leerlingen (
   leerling_id INT(10) UNSIGNED NOT NULL AUTO_INCREMENT,
   leerling_nummer INT(10) UNSIGNED NULL DEFAULT NULL,
   leerling_voornaam VARCHAR(50) NULL DEFAULT NULL COLLATE 'utf8mb4_general_ci',
   leerling_tussenvoegsels VARCHAR(10) NULL DEFAULT NULL COLLATE 'utf8mb4_general_ci',
   leerling_achternaam VARCHAR(50) NULL DEFAULT NULL COLLATE 'utf8mb4_general_ci',
   leerling_geboortedatum DATE NULL DEFAULT NULL,
   leerling_stamgroep VARCHAR(10) NULL DEFAULT NULL COLLATE 'utf8mb4_general_ci',
   PRIMARY KEY (leerling_id) USING BTREE
)
COLLATE='utf8mb4_general_ci'
ENGINE=InnoDB;

Een tabel vullen

Meestal wordt de tabel uiteindelijk gevuld door een (PHP)programma. Maar je kunt de tabel ook vullen via HeidiSQL. Hiervoor klik je met de rechtermuisknop in het data scherm en kiest voor "Voeg rij toe". Je kunt nu de velden voor de nieuwe rij vullen.

LET OP:
AUTO_INCREMENT velden laat je leeg, MySQL vult deze bij het opslaan.

 

SQL commando:
INSERT INTO leerlingen
(leerling_nummer, leerling_voornaam, leerling_tussenvoegsels, leerling_achternaam, leerling_geboortedatum, leerling_stamgroep)
 VALUES 
('12545', 'Mien', '', 'Dobbelsteen', '2004-06-10', 'H4B');

Rijen verwijderen

Om rijen te verwijderen selecteer je één of meerdere rijen in het data scherm. Vervolgens klik je met de rechtermuisknop op de geselecteerde rij en kies je voor "Verwijder geselecteerde rij(en)".

SQL commando:

DELETE FROM leerlingen WHERE leerling_id=21;

SQL syntax

De SQL syntax is erg uitgebreid. In deze module zullen we dan ook de meest voorkomende SQL opdrachten doornemen. Een compleet overzicht van de SQL syntax kun je vinden op de website van MySQL (https://dev.mysql.com/doc/refman/8.0/en/dynindex-statement.html)

Data selecteren, filteren en ordenen

Een van de voordelen van een SQL database is het gemak waarmee je data kunt selecteren, filteren en ordenen. Dit doe je met een "query". Vaak gebruik je HeidiSQL om query's te maken en testen. Dit doe je in het Query scherm.

 

Selecteren

Voor het selecteren van data gebruik je het SELECT commando. De syntax voor dit commando is:
SELECT kolom1, kolom2, ... FROM tabel_naam;
Door de kolomnamen van volgorde te veranderen verander je ook de volgorde van de data. In plaats van de kolomnamen mag je ook een wildcard (*) gebruiken om alle kolommen te selecteren.
SELECT * FROM tabel_naam;

Filteren

Om data te filteren gebruiken we het WHERE commando:
SELECT * FROM tabel_naam WHERE conditie;
Met de conditie die je meegeeft filter je de data.

Hieronder een aantal voorbeelden:
SELECT * FROM leerlingen WHERE leerling_voornaam="Piet";
Je krijgt nu alleen de rijen terug waarbij de voornaam gelijk is aan "Piet".
SELECT * FROM leerlingen WHERE leerling_voornaam="piet" OR leerling_voornaam="Klaas";
Je krijgt nu alleen de rijen terug waarbij de voornaam gelijk is aan "Piet" of "Klaas".
SELECT * FROM leerlingen WHERE leerling_voornaam="piet" AND leerling_achternaam="Vries";
Je krijgt nu alleen de rijen terug waarbij de voornaam gelijk is aan "Piet" en de achternaam gelijk is aan "Vries".
SELECT * FROM leerlingen WHERE leerling_nummer < 12346;
Je krijgt nu alleen de rijen terug waarbij het leerlingnummer kleiner is als 12346. Dit werkt ook bij datum velden.
Vaak wil je ook zoeken met wildcards. In SQL kan dat ook. Het wildcard teken is % :
SELECT * FROM leerlingen WHERE leerling_voornaam LIKE 'Pie%';
Je krijgt nu alleen de rijen terug waarbij de voornaam begint met "Pie". In ons geval Piet en Pien.
Wildcards mogen overal in de string staan.

Ordenen

Om de data te sorteren gebruik je het ORDER BY commando.
SELECT kolom1, kolom2, ... FROM tabel_naam ORDER BY kolom1, kolom2, ... ASC|DESC;
Hierbij geef je op welke kolommen gebruikt moeten worden voor de sortering.

SELECT * FROM leerlingen ORDER BY leerling_achternaam ASC,leerling_voornaam DESC;
Deze query sorteert de data eerst op achternaam (ASC: oplopend, van A naar Z) en bij gelijke achternaam op voornaam (DESC: aflopend, van Z naar A). Het commando ASC is niet strikt noodzakelijk, als je geen sorteervolgorde opgeeft gaat SQL er van uit dat je oplopend wilt sorteren.

Combineren

Je kunt alle bovenstaande commando's combineren tot één query:
SELECT * FROM leerlingen WHERE leerling_voornaam LIKE 'Pie%' ORDER BY leerling_achternaam ASC,leerling_voornaam DESC;
Je krijgt nu alleen de rijen terug waarbij de voornaam begint met "Pie". Gesorteerd op achternaam en voornaam. Let hierbij wel op de volgorde van de commando's. Het WHERE commando komt altijd voor het ORDER BY commando. Je moet ten slotte eerst filteren voordat je sorteert.

Toevoegen via SQL

Als je data toevoegt via HeidiSQL geeft deze op de achtergrond SQL commandos aan de database. Zo ook bij het toevoegen van data aan een tabel. Hiervoor gebruik je het commando INSERT.
INSERT INTO tabel_naam (kolom1, kolom2, kolom3, ...) VALUES ('waarde1', 'waarde2', 'waarde3', ...);

Een voorbeeld hiervan zijn we hierboven al tegen gekomen:
INSERT INTO leerlingen
(leerling_nummer, leerling_voornaam, leerling_tussenvoegsels, leerling_achternaam, leerling_geboortedatum, leerling_stamgroep)
VALUES
('12545', 'Mien', '', 'Dobbelsteen', '2004-06-10', 'H4B');

Updaten via SQL

Om data bij te werken gebruik je het commando UPDATE. Als een gebruiker van klas wisselt of een ander e-mail adres krijgt wil je de betreffende velden bijwerken:
UPDATE leerlingen SET leerling_stamgroep = 'H4D', leerling_geboortedatum = '2005-06-10' WHERE leerling_id = 1;
Met UPDATE kun je ook meerdere rijen tegelijk aanpassen:
UPDATE leerlingen SET leerling_stamgroep = 'H4D', leerling_geboortedatum = '2005-06-10' WHERE leerling_voornaam LIKE 'Pie%';
Alle leerlingen waarvan de voornaam begint met 'Pie' krijgen nu de klas 'H4D'.

LET OP:
UPDATE zonder WHERE veranderd alle rijen in de tabel.

Verwijderen via SQL

Via SQL kun je ook rijen weggooien met het DELETE commando. Hierbij is het van belang dat je de rijen goed kunt selecteren via het WHERE commando anders gooi je snel te veel weg en MySQL heeft geen prullenbak.
Voorbeelden van het DELETE commando zijn:
DELETE FROM leerlingen WHERE leerling_id=21;
DELETE FROM leerlingen WHERE leerling_voornaam LIKE 'Pie%';
DELETE FROM leerlingen WHERE leerling_nummer < '12346';

LET OP:
Als je geen selectie maakt (WHERE) gooi je alle rijen weg.
DELETE FROM leerlingen;
Deze query maakt de hele tabel leeg.

MySQL gebuiken in PHP

Een database word vooral gebuikt als opslag voor programma's. In dit hoofdstuk gaan we kijken hoe we met PHP de database kunnen vullen en bewerken. Er zijn verschillende connectoren om in PHP verbinding te maken met een MySQL database. In deze module maken we gebruik van PDO. Een database interface die geschikt is om verbinding te maken met meerdere database typen. In deze module gebruiken we MySQL, maar er zijn nog meer database varianten; PostgreSQL, Oracle, SQLite, Microsoft SQL Server, enz. Door PDO te gebruiken kun je van database variant wisselen zonder dat je jouw code hoeft aan te passen.

Verbinding maken

Om verbinding te maken met MySQL via PHP gebruik je het volgende PHP script:

<?php
$servername = "localhost"; // de servernaam, in ons geval localhost
$username = "root";        // de gebruikersnaam voor de database
$password = "";            // het wachtwoord, XAMPP heeft standaard geen wachtwoord, vandaar dat deze leeg
$database = "administratie"; // de naam van de database

try {
  $conn = new PDO("mysql:host=$servername;dbname=$database", $username, $password);
  // set the PDO error mode to exception
  $conn->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
  echo "Connected successfully";
} catch(PDOException $e) {
  echo "Connection failed: " . $e->getMessage();
}
?>

Als alles goed is gegaan krijg je op de website "Connected successfully" te zien.

MySQL-PHP Data ophalen

Data ophalen

Om data te kunnen selecteren kunnen we de volgende code gebruiken.
<?php
$servername = "localhost"; // de servernaam, in ons geval localhost
$username = "root";        // de gebruikersnaam voor de database
$password = "";            // het wachtwoord, XAMPP heeft standaard geen wachtwoord, vandaar dat deze leeg is
$database = "administratie"; // de naam van de database

try {
  $conn = new PDO("mysql:host=$servername;dbname=$database", $username, $password);
  // set the PDO error mode to exception
  $conn->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
  echo "Connected successfully";

  $stmt = $conn->prepare("SELECT * FROM leerlingen ORDER BY leerling_achternaam;"); // De query voorbereiden
  $stmt->execute(); // De query uitvoeren
  $result = $stmt->setFetchMode(PDO::FETCH_ASSOC); // Zet de modus op associatief; je krijgt nu een array terug met de kolomnamen als sleutel
   $data = $stmt->fetchAll();  // vul $data met de data
  foreach ($data as $row) { // loop door alle rijen en stop iedere keer een rij in $row
     // door de associatieve modus kun je de velden nu oproepen via de kolomnaam.
       echo $row["leerling_nummer"]."<br>";
       echo $row["leerling_voornaam"]."<br>";
       echo $row["leerling_tussenvoegsels"]."<br>";
       echo $row["leerling_achternaam"]."<br>";
       echo $row["leerling_geboortedatum"]."<br>";
       echo $row["leerling_stamgroep"]."<br>";
  }

} catch(PDOException $e) {
  echo "Connection failed: " . $e->getMessage();
}
?>

MySQL-PHP Data toevoegen

Data toevoegen

Om data toe te voegen kun je bijna dezelfde code gebruiken. Alleen de dataverwerking is niet meer aanwezig aangezien er bij een toevoeging geen data wordt opgehaald. In de onderstaande code voegen we een rij toe aan de database, hierna vragen we het AUTO_INCREMENT id op van de nieuwe rij.

<?php
$servername = "localhost"; // de servernaam, in ons geval localhost
$username = "root";        // de gebruikersnaam voor de database
$password = "";            // het wachtwoord, XAMPP heeft standaard geen wachtwoord, vandaar dat deze lee
$database = "administratie"; // de naam van de database

try {
  $conn = new PDO("mysql:host=$servername;dbname=$database", $username, $password);
  // set the PDO error mode to exception
  $conn->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
  echo "Connected successfully";

   // data toevoegen

   $sql="INSERT INTO leerlingen  (leerling_nummer, leerling_voornaam, leerling_tussenvoegsels, leerling_achternaam, leerling_geboortedatum, leerling_stamgroep) VALUES (:leerlingnummer, :leerlingvoornaam, :leerlingtussenvoegsel, :leerlingachternaam, :leerlinggeboortedatum, :leerlingstamgroep);";
   $params = [
        ":leerlingnummer"=> 12545,
        ":leerlingvoornaam"=> "Mien",
        ":leerlingtussenvoegsel"=> "",
        ":leerlingachternaam"=> "Dobbelsteen",
        ":leerlinggeboortedatum"=> "2004-06-10",
        ":leerlingstamgroep"=> "H4B"
   ];
   $stmt = $conn->prepare($sql);
   $stmt->execute($params);
   $newPrimaryKey = $conn->lastInsertId(); // het insert id kun je bijv. gebruiken in een andere tabel met extra gegevens. 

 

} catch(PDOException $e) {
  echo "Connection failed: " . $e->getMessage();
}
?>

MySQL-PHP Data aanpassen

Data updaten

Ook is het mogelijk om bestaande data bij te werken. Om dit te doen moeten we wel een uniek gegeven hebben zodat we de juiste rij kunnen aanpassen, vaak is dit een primairy key. In dit voorbeeld passen we de inhoud van de rij aan met id = 1.

<?php
$servername = "localhost"; // de servernaam, in ons geval localhost
$username = "root";        // de gebruikersnaam voor de database
$password = "";            // het wachtwoord, XAMPP heeft standaard geen wachtwoord, vandaar dat deze leeg
$database = "administratie"; // de naam van de database

try {
  $conn = new PDO("mysql:host=$servername;dbname=$database", $username, $password);
  // set the PDO error mode to exception
  $conn->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
  echo "Connected successfully";

   // data updaten
   $recordID = 1;
   $sql="UPDATE leerlingen SET leerling_stamgroep = :leerlingstamgroep, leerling_geboortedatum = :leerlinggeboortedatum WHERE leerling_id = :leerlingid;";
   $params = [
        ":leerlingid"=> $recordID,
        ":leerlinggeboortedatum"=> "2005-06-10",
        ":leerlingstamgroep"=> "H4D"
   ];
   $stmt = $conn->prepare($sql); // De query voorbereiden
   $stmt->execute($params); // De query uitvoeren

} catch(PDOException $e) {
  echo "Connection failed: " . $e->getMessage();
}
?>

MySQL-PHP Data verwijderen

Data verwijderen

Om een rij te verwijderen het je ook een unieke sleutel nodig, vaak is dat de primaire key. In dit voorbeeld verwijderen we de rij met id = 2;

<?php
$servername = "localhost"; // de servernaam, in ons geval localhost
$username = "root";        // de gebruikersnaam voor de database
$password = "";            // het wachtwoord, XAMPP heeft standaard geen wachtwoord, vandaar dat deze leeg
$database = "administratie"; // de naam van de database

try {
  $conn = new PDO("mysql:host=$servername;dbname=$database", $username, $password);
  // set the PDO error mode to exception
  $conn->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
  echo "Connected successfully";

   // data verwijderen
   $recordID = 2;
   $sql = "DELETE FROM leerlingen WHERE leerling_id = :leerlingid;";
   $params = [
        ":leerlingid"=> $recordID
   ];
   $stmt = $conn->prepare($sql); // De query voorbereiden
   $stmt->execute($params); // De query uitvoeren

} catch(PDOException $e) {
  echo "Connection failed: " . $e->getMessage();
}
?>

 

Ook is het mogelijk om meerder rijen tegelijk te verwijdren. Bijvoorbeeld iedreen met de voornaam "Henk":

<?php
$servername = "localhost"; // de servernaam, in ons geval localhost
$username = "root";        // de gebruikersnaam voor de database
$password = "";            // het wachtwoord, XAMPP heeft standaard geen wachtwoord, vandaar dat deze leeg
$database = "administratie"; // de naam van de database

try {
  $conn = new PDO("mysql:host=$servername;dbname=$database", $username, $password);
  // set the PDO error mode to exception
  $conn->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
  echo "Connected successfully";

   // data verwijderen
   $firstname = "Henk";
   $sql = "DELETE FROM leerlingen WHERE leerling_voornaam = :voornaam;";
   $params = [
        ":voornaam"=> $firstname
   ];
   $stmt = $conn->prepare($sql); // De query voorbereiden
   $stmt->execute($params); // De query uitvoeren

} catch(PDOException $e) {
  echo "Connection failed: " . $e->getMessage();
}
?>

Of iedereen die ouder is dan 18:

<?php
$servername = "localhost"; // de servernaam, in ons geval localhost
$username = "root";        // de gebruikersnaam voor de database
$password = "";            // het wachtwoord, XAMPP heeft standaard geen wachtwoord, vandaar dat deze leeg
$database = "administratie"; // de naam van de database

try {
  $conn = new PDO("mysql:host=$servername;dbname=$database", $username, $password);
  // set the PDO error mode to exception
  $conn->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
  echo "Connected successfully";

   // data verwijderen
   $sql = "DELETE FROM leerlingen WHERE leerling_leeftijd > :leeftijd;";
   $params = [
        ":leeftijd"=> 18
   ];
   $stmt = $conn->prepare($sql); // De query voorbereiden
   $stmt->execute($params); // De query uitvoeren

} catch(PDOException $e) {
  echo "Connection failed: " . $e->getMessage();
}
?>

PHP sessies

PHP sessies zijn een manier om informatie op te slaan in variabelen die gebruikt kunnen worden in meerdere PHP pagina's. Als voorbeeld nemen we een aanmeldpagina. Op de aanmeldagina word de gebruikersnaam en wachtwoord gecontroleerd en indien juist opgeslagen in sessievariablen. Nu kunnen we deze sessie variablen gebruiken in bijvoorbeeld de index pagina om te controleren of iemand is aangemeld. In tegenstelling tot een cookie wordt de informatie niet opgeslagen op de computer van de gebruiker, maar op de server. PHP sessies zijn dus handig voor het bijhouden van de identiteit en de voorkeuren van de gebruiker, bijvoorbeeld bij het inloggen of het winkelen.

Om een PHP sessie te starten, moet je de functie session_start () aanroepen aan het begin van elk PHP-script dat sessievariabelen wil gebruiken of lezen. Sessievariabelen worden ingesteld met de PHP globale variabele $_SESSION, die een associatieve array is. Bijvoorbeeld:

<?php
// Start de sessie
session_start ();

// Stel sessievariabelen in
$_SESSION["gebruikersnaam"] = "Jan";
$_SESSION["wachtwoord"] = "geheim";
?>

Om de waarde van een sessievariabele te lezen, gebruik je dezelfde $_SESSION array. Dit kan ook op een ander pagina. Bijvoorbeeld:

<?php
// Start de sessie
session_start ();

// Lees sessievariabelen
echo "Hallo " . $_SESSION["gebruikersnaam"] . "!<br>";
echo "Je wachtwoord is " . $_SESSION["wachtwoord"] . ".";
?>

Om een sessievariabele te wijzigen, overschrijf je hem gewoon met een nieuwe waarde. Bijvoorbeeld:

<?php
// Start de sessie
session_start ();

// Wijzig sessievariabelen
$_SESSION["wachtwoord"] = "nieuwgeheim";
?>

Om een sessievariabele te verwijderen, gebruik je de functie unset () of de functie session_unset (). Om een hele sessie te beëindigen, gebruik je de functie session_destroy (). Bijvoorbeeld:

<?php
// Start de sessie
session_start ();

// Verwijder individuele sessievariabelen
unset ($_SESSION["wachtwoord"]);

// Verwijder alle sessievariabelen
session_unset ();

// Vernietig de sessie
session_destroy ();
?>

PHP sessies kunnen gecombineerd worden met MySQL om gegevens op te slaan of op te halen uit een database. Dit kan handig zijn voor het maken van dynamische webapplicaties die afhankelijk zijn van gebruikersinvoer of -interactie. Bijvoorbeeld, stel dat je een database voor leerlingen hebt waar leerlingen hun gegevens kunnen aanpassen. Je kunt dan een tabel maken in MySQL die de leerlinggegevens. Vervolgens kun je een PHP-script schrijven dat alle gegevens uit een formulier haalt en het leerlingnummer uit een sessievariabele haalt. Het leerlingnummer is na het aanmelden van de leerling in een sessievariable opgeslagen. Op deze mannier kan de leerling nooit gegevens van iemand anders aanpassen. Bijvoorbeeld:

<?php

// Start de sessie
session_start ();

$servername = "localhost"; // de servernaam, in ons geval localhost
$username = "root";        // de gebruikersnaam voor de database
$password = "";            // het wachtwoord, XAMPP heeft standaard geen wachtwoord, vandaar dat deze lee
$database = "administratie"; // de naam van de database

try {
  $conn = new PDO("mysql:host=$servername;dbname=$database", $username, $password);
  // set the PDO error mode to exception
  $conn->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
  echo "Connected successfully";

   // data toevoegen met gegevens uit een formulier en sessie

   $sql="INSERT INTO leerlingen  (leerling_nummer, leerling_voornaam, leerling_tussenvoegsels, leerling_achternaam, leerling_geboortedatum, leerling_stamgroep) VALUES (:leerlingnummer, :leerlingvoornaam, :leerlingtussenvoegsel, :leerlingachternaam, :leerlinggeboortedatum, :leerlingstamgroep);";
   $params = [
        ":leerlingnummer"=> $_SESSION["Leerling_nummer"],
        ":leerlingvoornaam"=> $_POST["firstname"],
        ":leerlingtussenvoegsel"=> $_POST["prefix"],
        ":leerlingachternaam"=> $_POST["lastname"],
        ":leerlinggeboortedatum"=> $_POST["dob"],
        ":leerlingstamgroep"=> $_POST["group"]
   ];
   $stmt = $conn->prepare($sql);
   $stmt->execute($params);
   $newPrimaryKey = $conn->lastInsertId(); // het insert id kun je bijv. gebruiken in een andere tabel met extra gegevens.

 

} catch(PDOException $e) {
  echo "Connection failed: " . $e->getMessage();
}
?>

 

Voorbeeld 1

Maak een simple chat.

Maak een input veld voor de naam van de gebuiker en een input veld voor het bericht.
Als je op verstuur drukt, sla dan de naam en het bericht op in de database. Voeg aan ieder bericht een datum-tijd toe wanneer het bericht is opgeslagen. Laat de database dit automatisch doen.

Als de pagina geladen wordt, laat dan alle berichten zien boven de input velden. Sorteer deze op datum.

Uitwerking:

De database "chat" heeft 1 tabel: "chat" deze heeft 4 kolommen:

  • chat_id: van het type INT met auto_increasement en primary_key.
  • chat_nickname: van het type VARCHAR met een lengte van 50.
  • chat_message: van het type VARCHAR met een lengte van 500.
  • chat_datetime: van het type DATETIME met een standaard fuctie current_timestamp()

In SQL ziet dat er als volgt uit:

CREATE TABLE `chat` (
   `chat_id` INT(10) UNSIGNED NOT NULL AUTO_INCREMENT,
   `chat_nickname` VARCHAR(50) NOT NULL DEFAULT '' COLLATE 'utf8mb4_general_ci',
   `chat_message` VARCHAR(500) NOT NULL DEFAULT '' COLLATE 'utf8mb4_general_ci',
   `chat_datetime` DATETIME NULL DEFAULT current_timestamp(),
   PRIMARY KEY (`chat_id`) USING BTREE
)
COLLATE='utf8mb4_general_ci'
ENGINE=InnoDB;

De HTML met PHP ziet er als volgt uit:

<!DOCTYPE html>
<html lang="nl" dir="ltr">
  <head>
    <meta charset="utf-8">
    <title>Chat</title>
    <script type="text/javascript">
      document.addEventListener("DOMContentLoaded", function(event) {
        document.getElementById("message").focus();
      });
    </script>
  </head>
  <body>
    <?php
    $message="";
    if (isset($_POST["message"])){
      $message = $_POST["message"];
    }
    $nickname="";
    if (isset($_POST["nickname"])){
      $nickname = $_POST["nickname"];
    }

    $servername = "localhost";
    $username = "root";
    $password = "";
    $database = "chat";

    try {
      $conn = new PDO("mysql:host=$servername;dbname=$database", $username, $password);
      // set the PDO error mode to exception
      $conn->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
      if ($message!="" and $nickname!=""){
        $sql="INSERT INTO chat  (chat_nickname, chat_message) VALUES (:chat_nickname, :chat_message);";
        $params = [
               ":chat_nickname"=> $nickname,
               ":chat_message"=> $message
        ];
        $stmt = $conn->prepare($sql);
        $stmt->execute($params);
      }
      $stmt = $conn->prepare("SELECT * FROM chat ORDER BY chat_datetime;");
      $stmt->execute();
      $result = $stmt->setFetchMode(PDO::FETCH_ASSOC);
      $data = $stmt->fetchAll();
      foreach ($data as $row) {
        echo $row["chat_nickname"].": ";
        echo $row["chat_message"]."<br>";
      }
    } catch(PDOException $e) {
      echo "Connection failed: " . $e->getMessage();
    }
    ?>
    <form  action="index.php" method="post">
      <input type="text" name="nickname" value="<?php echo $nickname ?>" placeholder="nickname">
      <input id="message" type="text" name="message" value="" placeholder="message">
      <input type="submit" name="submit" value="Verstuur">
    </form>
  </body>
</html>

De javascript code zorgt ervoor dat het veld "message" na laden van de pagina de focus heeft.

Opdracht

Maak een PHP site waarop een gebruiker zich kan registreren en waar een gebruiker zich kan aanmelden.
De gebruiker moet de volgende gegevens invullen:

  • Voornaam
  • Tussenvoegsel
  • Achternaam
  • Wachtwoord

In de database worden de gegevens opgeslagen. Voor de wachtwoorden wordt gebruik gemaakt van hashes en salts.

 

Oplossing:

https://edu.hethooghuis.nl/informatica/phpmysql/bedrijf.zip

  • Het arrangement Module: MySQL is gemaakt met Wikiwijs van Kennisnet. Wikiwijs is hét onderwijsplatform waar je leermiddelen zoekt, maakt en deelt.

    Auteur
    Het Hooghuis Mondriaan informatica
    Laatst gewijzigd
    2023-06-06 09:58:45
    Licentie

    Dit lesmateriaal is gepubliceerd onder de Creative Commons Naamsvermelding 4.0 Internationale licentie. Dit houdt in dat je onder de voorwaarde van naamsvermelding vrij bent om:

    • het werk te delen - te kopiëren, te verspreiden en door te geven via elk medium of bestandsformaat
    • het werk te bewerken - te remixen, te veranderen en afgeleide werken te maken
    • voor alle doeleinden, inclusief commerciële doeleinden.

    Meer informatie over de CC Naamsvermelding 4.0 Internationale licentie.

    Aanvullende informatie over dit lesmateriaal

    Van dit lesmateriaal is de volgende aanvullende informatie beschikbaar:

    Eindgebruiker
    leerling/student
    Moeilijkheidsgraad
    gemiddeld
    Studiebelasting
    4 uur 0 minuten

  • Downloaden

    Het volledige arrangement is in de onderstaande formaten te downloaden.

    Metadata

    LTI

    Leeromgevingen die gebruik maken van LTI kunnen Wikiwijs arrangementen en toetsen afspelen en resultaten terugkoppelen. Hiervoor moet de leeromgeving wel bij Wikiwijs aangemeld zijn. Wil je gebruik maken van de LTI koppeling? Meld je aan via info@wikiwijs.nl met het verzoek om een LTI koppeling aan te gaan.

    Maak je al gebruik van LTI? Gebruik dan de onderstaande Launch URL’s.

    Arrangement

    Oefeningen en toetsen

    De Database

    Kolommen

    Datatype

    Attributen

    Indexen

    Forein Keys

    IMSCC package

    Wil je de Launch URL’s niet los kopiëren, maar in één keer downloaden? Download dan de IMSCC package.

    QTI

    Oefeningen en toetsen van dit arrangement kun je ook downloaden als QTI. Dit bestaat uit een ZIP bestand dat alle informatie bevat over de specifieke oefening of toets; volgorde van de vragen, afbeeldingen, te behalen punten, etc. Omgevingen met een QTI player kunnen QTI afspelen.

    Versie 2.1 (NL)

    Versie 3.0 bèta

    Voor developers

    Wikiwijs lesmateriaal kan worden gebruikt in een externe leeromgeving. Er kunnen koppelingen worden gemaakt en het lesmateriaal kan op verschillende manieren worden geëxporteerd. Meer informatie hierover kun je vinden op onze Developers Wiki.

  • Gebruik
    Weergave
  • Wikiwijs is een dienst van