MySQLi - Een nieuwe manier van interactie tussen PHP en MySQL

  1. Inleiding
  2. Proceduraal vs. Object georienteerd
  3. Object georienteerde interface van mysqli
  4. Meerdere queries tegelijk uitvoeren
  5. Prepared statements
  6. Transacties met mysqli: commit() en rollback()
  7. Uitbreiden van de mysqli klasse
  8. Slotwoord en referenties
  9. Reacties op deze tutorial

Proceduraal vs. Object georienteerd

Zoals ik in de inleiding al opmerkte, biedt de mysqli extensie ondersteuning voor zowel een procedurale als een object georienteerde interface.

In principe maakt het niets uit welke manier je gebruikt om met de database te communiceren, het is enkel een manier van programmeren. In deze tutorial zal ik voornamelijk gebruik maken van de object georienteerde manier maar omdat ik het procedurale gedeelte niet in zijn geheel over wil slaan, zal ik daar eerst aandacht aan besteden.

Procedurale interface
Het gebruik van de procedurale interface lijkt sterk op de oude manier van communiceren met de database. In plaats van de mysql_* functies, gebruik je nu echter de mysqli_* functies. De meeste functies zijn op een paar kleine dingetje na niet veranderd en de overstap zal dan ook niet erg lastig zijn.

Voorbeeld 1: Verbinding maken met de server
Code
1
2
3
4
5
6
7
<?php
$link = mysqli_connect('host', 'user', 'password', 'database');
if(!$link)
{
    trigger_error('Fout bij verbinden met database: '.mysqli_connect_error());
}
?>

Zoals je ziet wordt de mysqli_connect() functie op ongeveer dezelfde manier als de mysql_connect() functie gebruikt. Het enige verschil is dat de te selecteren database direct in de connect functie meegegeven worden. Het is nu dus niet meer nodig om een database te selecteren met mysqli_select_db().

Verder zien we in de foutafhandeling de functie mysqli_connect_error(). Voor het tonen van foutmeldingen veroorzaakt tijdens het maken van een verbinding gebruik je deze functie.

Voorbeeld 2: Selecteren van gegevens uit de database
Code
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
<?php
$link = mysqli_connect('host', 'user', 'password', 'database');
if(!$link)
{
    trigger_error('Fout bij verbinden met database: '.mysqli_connect_error());
}

$sql = "SELECT naam FROM tabel";
if(!$res = mysqli_query($link, $sql))
{
    trigger_error('Fout in query: '.mysqli_error());
}
else
{
    $aantal = mysqli_num_rows($res);
    echo 'Aantal records: '.$aantal;

    while($row = mysqli_fetch_assoc($res))
    {
        echo $row['naam'].'<br>';
    }
}
?>

Ook hier lijkt de gebruikte syntax zeer veel op de oude manier.

Er is echter een belangrijk punt waar je rekening mee moet houden als je de procuderale methode gebruikt. Elke bewerking die je op de database uitvoert vereist nu namelijk een link-identifier om aan te geven om welke verbinding het gaat. Vroeger was deze parameter optioneel, nu is hij dus verplicht.

Let ook op de volgorde van de parameters van de mysqli_query() functie. Deze is precies tegengesteld aan die van mysql_query():
Code
1
2
3
4
<?php
$res = mysqli_query($link, $sql);
$res = mysql_query($sql, $link);
?>

PHP zal natuurlijk vanzelf foutmeldingen genereren als je dit soort parameters verkeerd gebruikt.

Zoals ik al zei heeft bijna elke mysql_* functie een vergelijkbare mysqli_* functie. In principe zal er dus nog niet heel erg veel veranderen en zou je al prima uit de voeten moeten kunnen met de mysqli functies.

Object georienteerde interface
Voor de overzichtelijkheid van de tutorial zal ik nu alleen nog gebruik maken van de object georienteerde interface. Deze interface geniet mijn voorkeur aangezien je de mogelijkheid hebt om voor elke database verbinding een apart object aan te maken. Het voordeel hiervan is dat alle verschillende resultaten van een database verbinding als eigenschap van zo'n object beschikbaar zijn.

Voordat ik verder in ga op deze onderwerpen, zullen we eerst maar eens kijken naar het maken van een database verbinding en het uitvoeren van een simpel SELECT statement.

Voorbeeld 3: Verbinding maken met de server (2)
Code
1
2
3
4
5
6
7
<?php
$mysqli = new mysqli('host', 'user', 'password', 'database');
if(mysqli_connect_errno())
{
    trigger_error('Fout bij verbinding: '.$mysqli->error);
}
?>

We zien hier dat voor het maken van een database verbinding gebruik wordt gemaakt van de mysqli klasse die dezelfde parameters accepteert als de mysqli_connect() functie. Het voordeel is dat alle eigenschappen van deze verbinding, als eigenschap van het gecreeerde $mysqli object op te vragen zijn.

Het eerste voorbeeld daarvan is te zien in de foutafhandeling. Een eventuele foutmelding wordt opgehaald met $mysqli->error.

Voorbeeld 4: Selecteren van gegevens uit de database (2)
Code
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
<?php
$mysqli = new mysqli('host', 'user', 'password', 'database');
if(mysqli_connect_errno())
{
    trigger_error('Fout bij verbinding: '.$mysqli->error);
}

$sql = "SELECT naam FROM tabel";
if(!$result = $mysqli->query($sql))
{
    trigger_error('Fout in query: '.$mysqli->error);
}
else
{
    echo 'Aantal records: '.$result->num_rows;
    while($row = $result->fetch_assoc())
    {
        echo $row['naam'].'<br>';
    }
}    
?>

Voor het uitvoeren van een simpele SELECT query zien we dat er gebruik wordt gemaakt van de query() methode. Het resultaat van deze methode is een object $result waarin de resultaat set van de query te vinden is. We zien dat we in dit geval geen $link mee hoeven te geven aan de query() methode. Dat komt omdat deze informatie een eigenschap is van het object $mysqli en PHP dus al weet om welke verbinding het gaat.

Vanaf dit punt kan het resultaat gefetched worden met bijvoorbeeld de fetch_assoc() methode. Dit zal je redelijk bekend voorkomen omdat het natuurlijk veel lijkt op de mysql_fetch_assoc() functie. Let erop dat de fetch_assoc() methode wel bij het object hoort dat de resultaat set bevat, in ons geval dus $result.

Om bijvoorbeeld het aantal rijen in een resultaat set op te halen, hoeven we nu geen functie meer te gebruiken. Deze waarde is namelijk een eigenschap van het $result object. Het aantal rijen kunnen we dus heel eenvoudig met $result->num_rows achterhalen.

In deze tutorial zal ik laten zien hoe je de belangrijkste methodes en eigenschappen gebruikt. In de php.net handleiding vind je alle beschikbare methodes en eigenschappen.

Opmerking
Voor lezers die nog niet veel kennis hebben van object georienteerd programmeren (OOP): Een methode is een functie van een bepaalde klasse, beschouw het als een gewone php functie. Een eigenschap is een zoals het wordt al zegt een eigenschap van een bepaalde klasse, beschouw het al een variabele.

Een methode wordt aangeroepen met $object->methode() en een eigenschap geef je als weer als $object->eigenschap. Let op het verschil in haakjes.

Vorige Volgende