SQL Beginnershandleiding

  1. Inleiding
  2. De eerste tabel
  3. De database benaderen vanuit PHP
  4. PDO: De database benaderen vanuit PHP
  5. Invoegen van records
  6. PDO: Invoegen van records
  7. Selecteren van records
  8. PDO: Selecteren van records
  9. Wijzigen van records
  10. PDO: Wijzigen van records
  11. Verwijderen van records
  12. PDO: Verwijderen van records
  13. Sleutels en constraints
  14. Selecteren uit meerdere tabellen: JOINS
  15. Werken met data en tijden
  16. Aggregate functies en GROUP BY
  17. Debuggen: het oplossen van SQL fouten
  18. Slotwoord en referenties
  19. Reacties op deze tutorial

PDO: Invoegen van records

We hebben gezien hoe de SQL voor het invoegen van records in de database eruit ziet. Tijd om te zien hoe we dat met behulp van PDO doen.

Invoegen van een record (PDO)
De code voor het invoegen van een record met PDO ziet er als volgt uit.
Code
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
<?php
require_once 'db_config.php'

try
{
    
$sQuery "
        INSERT INTO werknemers
        (
            voornaam,
            tussenvoegsel,
            achternaam,
            geboortedatum,
            salaris_schaal
        )
        VALUES
        (
            'Nico',
            'de',
            'Boer',
            '1958-03-24',
            18
        ) 
    "
;
    
    
$oStmt $db->prepare($sQuery);
    
$oStmt->execute();
    
    
$id $db->lastInsertId();
}
catch(
PDOException $e)
{
    
$sMsg '<p>
            Regelnummer: '
.$e->getLine().'<br />
            Bestand: '
.$e->getFile().'<br />
            Foutmelding: '
.$e->getMessage().'
        </p>'
;
    
    
trigger_error($sMsg);
}
?>

We zien dat het eigenlijk helemaal niet zo lastig is om een record in te voegen in de tabel. Ook hier bevat $id nu weer het id van het laatst ingevoegde record.

Invoegen van gebruikersinput (PDO)
Het mooie van prepared statements in PDO is dat we geen functies als mysql_real_escape_string() meer nodig hebben om de data die we willen invoegen te beveiligen. In plaats daarvan geven we in eerste instantie in de query een aantal 'placeholders' op die later gevuld worden door de gegevens die door de gebruiker zijn ingevuld.

We nemen wederom onze fictieve tabel met voor- en achternaam waarbij deze wederom uit een formulier komen:
Code
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
<?php
require_once 'db_config.php';

try
{
    
$sQuery "
        INSERT INTO fictieve_tabel
        (
            voornaam,
            achternaam
        )
        VALUES
        (
            :voornaam,
            :achternaam
        )
    "
;
    
    
$oStmt $db->prepare($sQuery);
    
$oStmt->bindParam(':voornaam'$_POST['voornaam'], PDO::PARAM_STR);
    
$oStmt->bindParam(':achternaam'$_POST['achternaam'], PDO::PARAM_STR);
    
$oStmt->execute();
}
catch(
PDOException $e)
{
    
$sMsg '<p>
            Regelnummer: '
.$e->getLine().'<br />
            Bestand: '
.$e->getFile().'<br />
            Foutmelding: '
.$e->getMessage().'
        </p>'
;
    
    
trigger_error($sMsg);
}
?>

We zien in de query twee placeholders, :voornaam en :achternaam, welke later gevuld zullen worden door een voor en achternaam. Voordat we dat doen, laten we de query met prepare() eerst interpreteren en controleren door de database. Als dit gelukt is, kunnen we met bindParam() de waarden aan onze placeholders gaan koppelen.

De eerste parameter van de bindParam() methode is de placeholder waaraan een waarde gekoppeld wordt. De tweede parameter geeft de betreffende waarde, in ons geval dus een POST waarde uit het formulier. De laatste parameter is een constante die het type van de variabele aangeeft. In ons geval zijn het beide strings, wat we aangeven met PDO::PARAM_STR.

Tenslotte gebruiken we execute() om de query daadwerkelijk uit te voeren. Pas hier wordt het nieuwe record daadwerkelijk aan de tabel toegevoegd.

Invoegen van meedere records (PDO)
Het invoegen van meerdere records is met behulp van een prepared statement ook een fluitje van een cent:
Code
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
<?php
require_once 'db_config.php';

$aGegevens = array (
    array (
        
'voornaam' => 'Tim',
        
'tussenvoegsel' => '',
        
'achternaam' => 'Janssen',
        
'geboortedatum' => '1982-01-30',
        
'salarisschaal' => 10
    
),
    array (
        
'voornaam' => 'Pim',
        
'tussenvoegsel' => '',
        
'achternaam' => 'Vosse',
        
'geboortedatum' => '1982-01-30',
        
'salarisschaal' => 10
    
)
);

try
{
    
$sQuery "
        INSERT INTO werknemers
        (
            voornaam,
            tussenvoegsel,
            achternaam,
            geboortedatum,
            salaris_schaal
        )
        VALUES
        (
            :voornaam,
            :tussenvoegsel,
            :achternaam,
            :geboortedatum,
            :salarisschaal
        ) 
    "
;
    
    
$oStmt $db->prepare($sQuery);
    
$oStmt->bindParam(':voornaam'$sVoornaamPDO::PARAM_STR);
    
$oStmt->bindParam(':tussenvoegsel'$sTussenvoegselPDO::PARAM_STR);
    
$oStmt->bindParam(':achternaam'$sAchternaamPDO::PARAM_STR);
    
$oStmt->bindParam(':geboortedatum'$sGeboortedatumPDO::PARAM_STR);
    
$oStmt->bindParam(':salarisschaal'$iSalarisschaalPDO::PARAM_INT);
    
    foreach(
$aGegevens as $aRecord)
    {
        
$sVoornaam $aRecord['voornaam'];
        
$sTussenvoegsel $aRecord['tussenvoegsel'];
        
$sAchternaam $aRecord['achternaam'];
        
$sGeboortedatum $aRecord['geboortedatum'];
        
$iSalarisschaal $aRecord['salarisschaal'];
        
        
$oStmt->execute();
    }
}
catch(
PDOException $e)
{
    
$sMsg '<p>
            Regelnummer: '
.$e->getLine().'<br />
            Bestand: '
.$e->getFile().'<br />
            Foutmelding: '
.$e->getMessage().'
        </p>'
;
    
    
trigger_error($sMsg);
}
?>

Allereerst maken we een array aan waarin we alle gegevens voor de verschillende records zetten. Vervolgens geven we in de query de benodigde placeholders op en laten we hem weer interpreteren en controleren door de database.

Met de bindParam() methode koppelen we vervolgens variabelen aan de verschillende placeholders zodat er straks bij het aanroepen van execute() ook daadwerkelijk waarden toegekend worden.

Het daadwerkelijk aanroepen van execute() en dus het uitvoeren van de query, doen we nu binnen een foreach-loop waarmee we de gegevens array uitlezen. In elke loop kennen we de waarden uit de gegevens array toe aan de variabelen die we in de bindParam() gedefinieerd hebben. Vervolgens voeren we de query uit met execute().

Het voordeel van deze methode is dat de query zelf niet verandert. We hoeven nu enkel nog de array $aGegevens te veranderen als we meerdere of andere records in willen voegen. We kunnen deze array zelfs dynamisch opbouwen aan de hand van gegevens uit een formulier!

Vorige Volgende