PHP en MySQL

Apache en IIS
Arrays
Commentaar in PHP
Controlestructuren in PHP
Default locatie van een MySQL-database
Default locatie van PHP-Scriptfiles wijzigen
Foutmeldingen in PHP
Functies gebruiken in PHP
Join

Kennis maken met PHP
Meerdimensionale arrays
Een MySQL-database maken en gebruiken
MySQL opdrachten via PHP
Objects
Operatoren in PHP
Opstarten Wampserver (MySQL en PHP)
PHP in HTML
phpMyAdmin
Root password in MySQL

String- functies
Var_dump arrays
Variabelen gebruiken in PHP
Variabelen vrijgeven en type achterhalen
Variabelescope
Veldtypes in MySQL
Werken met Arrays

Met PHP kunnen krachtige webapplicaties gebouwd worden.
PHP met MySQL wordt vaak in combinatie met de webserver Apache gebruikt, maar zij werken ook goed samen met IIS (Internet Information Server van MicroSoft)

Apache en IIS

Het is niet mogelijk om op één machine zowel de Apache als de IIS server te laten draaien.
Als IIS eenmaal draait en men probeert vervolgens ook de Apache server op te starten verschijnt de melding:
Windows cannot start the server, specifieke foutcode is: 1 (0x1).
Oplossing: stop de IIS server!

Om te zien welke services op de achtergrond draaien gebruiken we (in Windows 7) de Administrative tools.

Het is wellicht ook handig om meteen alles wat met MicroSoft SQL-server te maken heeft ook meteen te stoppen om eventuele problemen met MySQL te voorkomen.

Opstarten Wampserver (MySQL en PHP)

Zorg er vervolgens voor dat de WampApache en WampMySQL services worden opgestart:

Eerst de manager opstarten	En daarna vervolgens de services zelf opstarten

Test de Wamp services door met de browser naar de volgende URL te gaan: http://localhost/

Default locatie van PHP scriptfiles wijzigen

Default moeten de scripts die men aanmaakt geplaatst worden in de directory:
D:\wamp\www ; waarbij D: de gekozen installatie schijf is.

Om deze default locatie te wijzigen moet men het bestand D:\wamp\bin\apache\Apache2.2.11\conf\httpd.conf editen.

#
.
#
# DocumentRoot: The directory out of which you will serve your
# documents. By default, all requests are taken from this directory, but
# symbolic links and aliases may be used to point to other locations.
#
# Veranderd door Raymundo
#
# DocumentRoot "D:/wamp/www/"
DocumentRoot "E:/Raymundo/PHP_en_MySQL/PHPscripts"

#
#
# This should be changed to whatever you set DocumentRoot to.
#
# Veranderd door Raymundo
#
# <Directory "D:/wamp/www/">
<Directory "E:/Raymundo/PHP_en_MySQL/PHPscripts">
.
.
.

Let op: dit moet dus op twee locaties in het bestand!

Verander de variabele documentroot naar de gewenste directory.

Let op de forward / i.p.v. de bachward \

Kennis maken met PHP

PHP is een afkorting voor: PHP: Hypertext Preprocessor.
In de open source wereld worden vaak recursieve acroniemen gebruikt; bijv. GNU: GNU is not Unix.

PHP is ooit ontstaan als een uitvinding van Rasmus Lerdorf. Hij bouwde aanvankelijk - halverwege de jaren negentig - slechts een bibliotheek met C-functies voor connecties met een database, het interpreteren van formuliervelden enz. Intussen wordt PHP toegepast in ruim 10 miljoen websites en geldt het als verreweg de meest succesvolle concurrent van Microsoft's ASP en Sun's JSP (Java Serverpages).

Actieve webpagina's

Toen internet nog niet zo lang bestond waren verreweg de meeste webpagina's statisch.
De oudste manier om pagina's actief te maken heet CGI (Common Gateway Interface).
Nadeel van CGI is dat je moet kunnen programmeren in bijv. C. Al snel ontstonden alternatieven zoals Perl.
PHP is een uitbreiding van Perl en dus kunnen we PHP net als Perl als een uitbreiding van CGI beschouwen.

Server Side Scripting

PHP is net als JavaScript een scripttaal, maar .... JavaScript wordt op de PC van de gebruiker uitgevoerd, terwijl PHP op de server draait.
M.a.w. als de bron van een webpagina wordt weergegeven is de kans groot dat u JavaScript tegenkomt, maar PHP zeker niet!

Neem figuur uit boek over!! (blz. 17 fig 1.15)

ZEND

ZEND bevat verschillende onderdelen die helpen om PHP-scripts te schrijven en uit te voeren. Dankzij ZEND worden de scripts sneller uitgevoerd, omdat ZEND de code compileert en optimaliseert.
Dat gebeurt overigens allemaal automatisch en achter de schermen. U merkt er niets van en hoeft er geen instellingen voor bij te houden.

Er is ook een zend development Environment (zend studio www.zend.com).

PHP in HTML

Er zijn verschillende manieren om PHP op te nemen in een webpagina.

<><?php /* allemaal PHP-code */ ?>	XML-stijl
<? /* allemaal PHP-code */ ?>	Om deze short tags te kunnen gebruiken moet in de PHP.INI bestand de volgende instelling worden gezet: short_open_tag = on

Variabelen, operatoren en functies

We starten met een praktijkvoorbeeld: boeken bestellen.

<h2>Bestel uw boek</h2>

<form action="afhandel.php" name="bestelling" action="get">

<table>

	<tr>

		<th>Titel</th>

		<th>Aantal</th>

	</tr>

	<tr>

		<td>PHP in mootjes</td>

		<td><input type="text" name="PHPqt" size="3"></td>

	</tr>

	<tr>

		<td>MySQL doorgelicht</td>

		<td><input type="text" name="MySQLqt" size="3"></td>

	</tr>

	<tr>

		<td>Apache op pad</td>

		<td><input type="text" name="Apacheqt" size="3"></td>

	</tr>

	<tr colspan="2">

		<td><input type="submit"></td>

	</tr>

</table>

</form>

Voor de afhandeling door PHP op uw server is belangrijk wat ingevuld staat als action-attribuut binnen de form-tag.
Het action-attribuut geeft aan: afhandel.php. Nadat de gebruiker op de knop Submit heeft geklikt, gaat de browser naar de URL die in het action-attribuut aangegeven is.
Omdat de webpagina de extensie php heeft, zal de server alle scriptcode die op de pagina voorkomt door de PHP-engine laten uitvoeren.

Een belangrijk parameter van een invoerveld is zijn naam: attribuut name.
U mag de naam vrij kiezen, maar aan te raden is dat u in de naam tot uitdrukking brengt, welk gegeven dit veld bevat. Hier bijvoorbeeld PHPqt (PHP is naam van het boek en qt staat voor quantitiy).

Klik hier voor een werkend voorbeeld.

Waar worden de eigen scripts geplaatst??

Let op: de PHP scrips moeten in de subdirectory www onder de wamp installatie directory worden geplaatst.
(bij ons dus: D:\wamp\www)

En de form tag komt er dan als volgt uit te zien:

<form action="http://localhost/afhandel.php" name="bestelling" action="get">

Om ervoor te zorgen dat je de PHPscripts in een andere directory dan 'D:\wamp\www' geplaatst kunnen worden moeten we in de http.conf file (te vinden in: 'D:\wamp\bin\apache\Apache2.2.11\conf') TWEE wijzigingen aanbrengen (overal D:/wamp/www/ vervangen door eigen locatie):

1. DocumentRoot "E:/Data/PHPscripts/"

2.
# <Directory "D:/wamp/www/">
<Directory "E:/Data/PHPscripts/">

Verder kun je het bestand index.php welke standaard in de directory D:/wamp/www staat copiëren naar de nieuwe locatie. Wel moet dan de inhoud gewijzigd worden anders krijg je foutmeldingen bij de url: //http:localhost:
//chemin jusqu'au fichier de conf de WampServer
// $wampConfFile = '/wampmanager.conf';
// changed by Raymundo R. Hordijk
$wampConfFile = 'D:/Wamp/wampmanager.conf';

Hoe worden de eigen scripts getest??

Dit kan op twee manieren:

Schrijf een HTML document met daarin een formulier en een submit knop zoals hiernaast is weergegeven
Bij recht toe recht aan scripts, plaats de script in de www subdirectory en open hem in een web-browser m.b.v. de URL: http://localhost/scriptnaam.php

<?php

  // dit script handelt de invoer af van

  // bestel.htm

  $PHPqt = $_REQUEST["PHPqt"];

  $MySQLqt = $_REQUEST["MySQLqt"];

  $Apacheqt = $_REQUEST["Apacheqt"];

  echo "U bestelde:<br>";

  echo "$PHPqt PHP in mootjes<br>";

  echo "$MySQLqt MySQL doorgelicht<br>";

  echo "$Apacheqt Apache op pad<br>";

?>

Hier is de inhoud van afhandel.php.
Enkele opmerkingen:
1. // wordt net als in C gebruikt voor commentaar op één regel;
Voor een blok kan ook /* */ gebruikt worden.
2. Elke variabelenaam begint met een $-teken;
3. Het echo commando wordt gebruikt om een interactieve html bestand aan te maken (de functie print is ook te gebruiken).

Variabelen gebruiken in PHP

Net als in de meeste scripttalen is het in PHP niet nodig variabelen te declareren voor gebruik. Sterker nog, het kan niet eens!

PHP is 'loosly typed', d.w.z. dat een variabele van een bepaald type in bepaalde operaties automatisch geconverteerd wordt naar een ander type.
Van welk type een variabele is, hangt dus telkens opnieuw af van de context waarin hij gebruikt wordt.

Een variabele naam:

begint met een $-teken;
mag geen spaties of operator (+, -, /, %, &) bevatten;
mag niet met een cijfer beginnen.

In PHP zijn de namen van variabelen hoofdletter gevoelig!
De namen van functies zijn overigens niet hoofdletter gevoelig!

Een variabele kan niet gedeclareerd worden, maar een variabele moet wel geïnitialiseerd zijn voor gebruik!

Gegevenstypen in PHP

Natuurlijk zijn variabelen altijd wel van een bepaald type, ook al worden ze niet gedeclareerd.
PHP kent 8 soorten variabelen:

vier enkelvoudige typen (booleans, integers, reals = floating point, en strings);
twee samengestelde typen (arrays en objecten);
de speciale typen resource en NULL.

Booleans

$is_logged_in = true; // true heeft de waarde 1
$is_home = false; // false heeft als waarde een lege string! Let op NIET 0

Integers

$getal = 2009   // decimaal
$getal = o753    // octaal, is decimaal 7*64 + 5*8 + 3 = 491
$getal = 0x10F    // hexadecimaal, is 1*256 + 0*16 + 15 = 271

Reals = drijvende komma-getallen

$getal = 3.14 // decimaal
$getal = 0.314E1 //0.314 maal 10 tot de macht 1 oftewel 3.14

Strings

Er zijn twee manieren waarop in PHP aan strings een waarde kan worden toegekend:

Met enkele quotes (unparsed strings)
$programeur = 'Raymundo'
Met dubbele quotes (parsed strings)
dit levert een schat aan mogelijkheden o.a.:

expansie van variabelen;
ondersteuning van string-escapes tekens bij <pre> ..... </pre> teksten(\n en \t bijvoorbeeld)

<?php

$programmeur = 'Rasmus Lerdorf';

$zin1 = 'Beste $programmeur!'; // Beste $programmeur!

$zin2 = "Beste $programmeur!"; // Beste Rasmus Lerdorf!

$zin3 = "Regel\nVolgende regel\ttab\tna tab";

echo '<pre>';

echo '1. '. $zin1 . '<br>';

echo '2. ' . $zin2 . '<br>';

echo '3. ' . $zin3 . '<br>';

echo '</pre>';

?>

Hiernaast staat een voorbeeld.
Klik hier voor een HTML document waarin dit voorbeeld wordt toegepast, of open in de browser het bestand:
http://localhost/doublequotes.php

Uitvoer:

1. Beste $programmeur!
2. Beste Rasmus Lerdorf!
3. Regel
Volgende regel	tab	na tab

Let op de punt (.) wordt als concatenatie-teken gebruikt.

Arrays

Een array is een lijst van variabelen onder dezelfde naam, te benaderen via een numerieke index (startend bij 0).
In een klassieke array moeten alle variabelen van hetzelfde type zijn.
In PHP daarentegen vinden we arrays met twee grote verschillen:

associatieve arrays waarbij de afzonderlijke variabelen te benaderen via een string;
in een PHP array mag van alles zitten, de elementen mogen bijvoorbeeld integers, strings of objecten zijn, alles door elkaar.

Voorbeeld 1: klassiek array	<?php $kleuren[0] = "rood"; $kleuren[1] = "geel"; $kleuren[2] = "zwart"; $kleuren[3] = "groen"; for($i=0; $i<=3; $i++) { echo("$kleuren[$i]<br>"); } ?>
Voorbeeld 2: associatieve array	<?php $kleuren=array("a"=>"rood" , "b"=>"groen", "c"=>"geel", "d"=>"zwart"); while(list($sleutel, $waarde) =each($kleuren)) { echo("sleutel: $sleutel , waarde: $waarde <br>"); } ?>
Voorbeeld 3: verschillende datatypen	<?php $kleuren[0] = "rood"; $kleuren[1] = 10; $kleuren[2] = "zwart"; $kleuren[3] = 3.14; for($i=0; $i<=3; $i++) { echo("$kleuren[$i]<br>"); } ?>

Zie voor veel meer arrays!

Objects

Objecten zijn UDT's, User Defined Types. De definitie van zo'n type gebeurt met het sleutelwoord class.
definities leiden op zich niet tot bruikbare variabelen. In tegenstelling tot de standaard typen (integer enz.) moeten objecten in PHP verplicht gedeclareerd worden voordat u ze gebruikt.
De new-operator dient om objecten te maken van een bepaald type. Deze operator wordt ook wel de aanroep van de constructor genoemd.
Het creëren van objecten wordt ook wel instantiatie genoemd: men maakt één of meer instanties van een klasse.

Als u één of meer constructoren zelf schrijft in PHP, kan dat op twee manieren:

als functie binnen de klasse met dezelfde naam als de klasse;
met het sleutelwoord __construct (dit sleutelwoord begint met een dubbele underscore).

Een constructor heeft per definitie geen terugkeerwaarde. Wel mag een constructor eventueel parameters meekrijgen, zodat een nieuwe instantie van de klasse gelijk bepaalde beginwaarden mee kan krijgen.
Er mogen in PHP geen verschillende constructoren (met verschillende parameters) zijn!

Voorbeeld 1: Object zonder constructor

<?php
class Auto
{
// Een demoklasse die een auto voorstelt
var $snelheid;
var $versnelling = 0;

function geefGas()
{
 $this->snelheid += 10;
 if ($this->snelheid / 20 > $this->versnelling)
 {
 $this->versnelling++;
 }
}
}
// demonstreer de werking van een Auto
$myAuto = new Auto;
$myAuto->geefGas();
$myAuto->geefGas();
echo "snelheid: $myAuto->snelheid ";
echo "versnelling: $myAuto->versnelling ";
?>

Voorbeeld 2: Overerving

<?php
// werknemer.php

class Persoon
{
var $naam, $leeftijd;

// constructor
function Persoon($naam, $leeftijd)
{
 $this->naam = $naam;
 $this->leeftijd = $leeftijd;
}
}

$p = new Persoon('Hans', 25);
echo "'$p->naam' is $p->leeftijd jaar. \n";

class Werknemer extends Persoon
{
var $salarisschaal;

// constructor
function Werknemer($naam, $leeftijd, $salarisschaal)
{
 // aanroep constructor van de superklasse
 $this->Persoon($naam, $leeftijd);
 $this->salarisschaal = $salarisschaal;
}
}

$w = new Werknemer('Pietro', 34, 10);
echo "'$w->naam' is $w->leeftijd en zit in schaal $w->salarisschaal. \n";
?>

Resources

Als in een programma een database wordt geopend, wordt gebruik gemaakt van resources om gegevens (het kanaal enz.) van de geopende database in op te slaan.
Een resouce is wat in C een handle wordt genoemd.
Naast een verbinding met een database kon ook een tekenoppervlak een resource zijn

Null

Als een variabele geen waarde heeft (nooit gehad, de variabele bestaat nog niet) dan heeft deze de waarde NULL.
Het nut van NULL is tweeledig:

in een programma kan ermee onderzocht worden of een variabele al bestaat;
anderzijds kan een variabele ermee vrijgegeven worden.

if (is_null($variabele)) ....
$variabele = NULL; variabele weg

Bedenk wel dat een string of array heel groot kan zijn dus het vrijgeven van geheugen door een null-toewijzing kan zeker nuttig zijn.

Variabelen vrijgeven en type achterhalen

Als een variabele niet meer gebruikt wordt kan deze ook worden vrijgegeven m.b.v. de functie unset( ).
Als u het huidige gegevenstype van een variabele wilt achterhalen kan hiervoor de functie gettype( ) worden gebruikt.
Om te testen of een variabele van een bepaald type is zijn de functies aanwezig:

is_array( );
is_bool( );
is_float( );
is_int( );
is_null( );
is_numeric( );
is_object( );
is_string( ).

Voorbeeld van verschillende variabele typen.

      <html>

<head>

    <title>Gegevenstypen in PHP</title>

</head>

<body>

<?php

    $is_logged_in = true;   
           
       // type: boolean

    $is_in = false;       
           
         // type: boolean

    $int_var = 10;       
           
          // type: integer

    $double_var = 19.95;    
           
       // type: double

    $string_var = "<h2>Hello
World</h2>";       // type: string

    $arry_var[0] = "peter";    
       
        // type: array

    class Persoon        
           
          // type: object

    {

        var $naam, $leeftijd;

        // constructor

        function Persoon($naam,
$leeftijd) 

        {

            $this->naam
= $naam;

$this->leeftijd = $leeftijd;

        }

    }

    $p = new Persoon('Hans', 25);

    print('De variabele $is_logged_in is van het type: '
. gettype($is_logged_in) .

            " en
heeft de waarde: $is_logged_in <br>"

         );

    print('De variabele $is_in is van het type: ' .
gettype($is_in) .

           " en heeft de
waarde: $is_in <br>"

         );

    print('De variabele $int_var is van het type: ' .
gettype($int_var) .

           " en heeft de
waarde: $int_var <br>"

         );

    print('De variabele $double_var is van het type: ' .
gettype($double_var) .

           " en heeft de
waarde: $double_var <br>"

         );

    print('De variabele $string_var is van het type: ' .
gettype($string_var) .

           " en heeft de
waarde: $string_var <br>"

         );

    print('De variabele $arry_var is van het type: ' .
gettype($arry_var) .

           " en heeft de
waarde: $arry_var <br>"

         );

    print('De variabele $p is van het type: ' .
gettype($p) .

           " en heeft de
waarde: $p->naam <br>"

         );   
     
    echo "$p->naam is $p->leeftijd
jaar.<BR>";

    if(is_float($double_var))

    {

        print("$double_var is een
floating point variabele <br>");

    }

    else

    {

        print("$double_var is geen
floating point variabele <br>");

    }

?>

</body>

</html>

Operatoren in PHP

In een expressie worden de elementen met elkaar verbonden door operatoren.
Je hebt verschillende soorten operatoren:

rekenkundige operatoren (+, -, *, /),
één toekenningsoperator(=),
increment en decrement(++,--),
vergelijkingsoperatoren(= =, !=, >, <, <=, >=),
logische vergelijkingsoperatoren(&&, ||, !),
en een stringoperator(.). Deze verbindt 2 strings met elkaar.

Samengestelde Operatoren in PHP

Samengeselde operatoren worden ook wel shorthand operators genoemd.

Traditioneel	Notatie met samengestelde operatoren
$var = $var + 1;	$var++;
$var = $var - 1;	$var--;
$var = $var + 10;	$var += 10;
$var = $var - 10;	$var -= 10;
$var = $var * 10;	$var *= 10;
$var = $var / 10;	$var /= 10;
$var = $var . "tien";	$var .= 10; //voeg de string "tien" toe aan $var
$var1 = 10; $var2 = 10; $var3 = 10;	// ken het getal 10 toe aan elke variabele $var1 = $var2 = $var3 = 10;

Controlestructuren in PHP

Men spreek over program flow of branching. Er zijn vijf basisstatements voor controlestructuren:

1. If -else	if (conditie) { //statements_if_true; } else { //statements_if_false; }	<html> <head> <title>Een onbedoeld if-statement</title> </head> <body> <?php $getal = 10; if ($getal = 20) { // bedoeld wordt: if($getal == 20){... echo "Het getal is 20"; } else { echo "Het getal is niet 20"; } ?> </body>
2. switch	switch($variabele) { case <constant1>: // statements; break; case <constant2>: // statements; break; default: // statements bij geen match; }	<html> <head> <title>Het statement switch()</title> </head> <body> <?php $fruit = "appel"; switch($fruit) { case "banaan": echo "Uw favoriete fruit is een banaan"; break; case "peer": echo "Uw favoriete fruit is een peer"; break; case "appel": echo "Uw favoriete fruit is een appel"; break; default: echo "Uw favoriete fruit is onbekend"; } ?> </body> </html>
3. while	while (conditie) { //statements; }	<html> <head> <title>De while statement</title> </head> <body> <?php $i = 1; $getal = 10; echo "<pre>"; while ($i <= 10) { echo "$i \tmaal $getal = \t" . $i * $getal . "<br>"; $i++; } echo "</pre>"; ?> </body> </html>
4. do-while	do { //statements; } while(conditie)	<html> <head> <title>De lus do-while()</title> </head> <body> <?php $i = 1; $getal = 10; do { echo "$i maal $getal = " . $i * $getal . "<br>"; $i++; }while ($i <= 10) ?> </body> </html>
5. for ( )	for ($index; conditie; indexbewerking) { //statements; }	ml> <head> <title>Een for()-lus</title> </head> <body> <?php $getal = 15; for($i=1; $i<=10; $i++) { echo "$i maal $getal = " . $i * $getal . "<br>"; } ?> </body> </html>

Functies gebruiken in PHP

Een functie is een blok met opdrachten die een naam heeft.
Een functie kan eventueel één of meer waarden meekrijgen (de argumenten of parameters).
Een functie kan eventueel één waarde teruggeven: de terugkeerwaarde.

Functies hebben de volgende voordelen:

functiecode hoeft maar één maal gecompileerd te worden;
programma wordt beter leesbaar, overzichtelijker;
programma wordt beter onderhoudbaar aangezien eventuele wijzigingen slechts op één plaats moeten worden aangebracht en getest.

U roept een functie aan bij zijn naam, waarop altijd haakjes volgen. Ook lege haakjes, voor een aanroep zonder parameters, moeten worden geschreven, omdat het systeem anders niet weet dat het om een functie gaat.

PHP kent drie verschillende typen functies:

ingebouwde functies (language constructs), deze maken deel uit van de programmeertaal PHP zelf;
vb: echo, empty, exit, die en print.
externe functies, deze worden in aparte bibliotheken gedefinieerd maar u kunt ze rechtstreeks vanuit PHP aanroepen;
vb: kalenderfuncties, databasefuncties, pdf-functies er zijn er duizenden.
gebruikersgedefinieerde functies (user defined functions) zijn functies die u zelf schrijft.

User defined functions

Een functie wordt gedefinieerd met het keyword function
Elke functie heeft een naam; de functienaam is niet hoofdletter gevoelig.
De parameterlijst mag leeg zijn, achter een parameter kan desgewenst direct een standaardwaarde worden opgegeven.
Functies kunnen desgewenst één waarde retourneren. Hiervoor wordt het return statement gebruikt.

<?php
 function functienaam($parameter1, $parameter2, ....)
 {
 // code binnen de functie;
 // return berekende waarde;
 }
?>

Het maakt PHP niet uit in welke volgorde functie worden gedefinieerd en gebruikt.
Algemene en veel gebruikte functies worden daarom ook gegroepeerd in de header van het webdocument of in een apart bestand als mijn_functies_incl.php opgeslagen en met include( ) of require( ) in de pagina geplaatst.

Het verschil tussen include( ) en require( )

Voor het invoegen van bestanden in een ander bestand heeft u de keuze uit vier opdrachten:
include( ) en include( )_once
require( ) en require( )_once

Het enige verschil tussen include( ) en include( )_once (en require( ) en require( )_once) is het aantal keren dat het bestand ingevoegd wordt.
Als include( )_once of require( )_once wordt gebruikt, kan het bestand niet meerdere keren worden geladen. Niet met opzet, maar ook niet per ongeluk. Zo voorkomt u dat bijvoorbeeld een functie twee keer of vaker wordt gedefinieerd. Dat is immers verboden.

Verschil tussen include( ) en require( )

require( )	bestand wordt altijd geïmporteerd ook al wordt het nooit gebruikt
include( )	bestand wordt alleen ingelezen indien de code ook echt gebruikt wordt.

Een voorbeeld: btw berekenen

<html>
<head>
 <title>Een functie om de BTW te berekenen</title>
</head>

<body>
<?php
//initialisatie constanten
define ("BTW_HOOG", 0.19);
define ("BTW_LAAG", 0.06);

function bereken_btw($bedrag, $tarief="H"){
 if ($tarief == "L"){
 return ($bedrag * BTW_LAAG);
 }
 elseif($tarief == "H"){
 return ($bedrag * BTW_HOOG);
 }
 else{
 return "onbekend" ;
 }
}

// initialisatie
$bedrag = 25;
$btw = bereken_btw($bedrag, "H");
$totaal = $bedrag + $btw;

echo ("De btw over $bedrag euro bedraagt $btw euro (totaal: $totaal euro)");
?>

</body>
</html>

Boven in het script worden twee constanten gedefinieerd.
Met define( ) kunt u een constante waarde koppelen aan een makkelijk te begrijpen omschrijving

Klick hier voor een werkend voorbeeld.

Let op: het echo commando mag met of zonder haakjes gebruikt worden.
Dus:
echo 'Dit is een echo'
of
echo('Dit is een echo')

Variabelescope binnen functies

Een variabele die buiten een functie is gedeclareerd (beter is te spreken over gebruikt, want variabelen worden in PHP NIET gedeclareerd voor gebruik) is zichtbaar voor alle code maar NIET binnen een functie! Deze variabele bevindt zich in de global scope.

Een variabele die binnen een functie is gebruikt, is alleen binnen die functie zichtbaar: local scope

De scope van een variabele is beperkt tot de pagina waarin hij gemaakt is. Wil je variabelen naar andere (internet)pagina's meenemen dan moet men gebruik maken van cookies, formuliervariabelen of sessions.

Constanten die zijn gedefinieerd met define () zijn overal te gebruiken. Ook zij hebben global scope.

<html> <head> <title>Scope van variabelen</title> </head> <body> <?php // initialisatie: variabelen zichtbaar in globale scope $mijn_var1 = "Hello "; $mijn_var2 = "World!"; function doe_iets() { global $mijn_var1; // $mijn_var1 nu ook bruikbaar binnen functie echo $mijn_var1; // uitvoer: Hello echo $mijn_var2; // uitvoer: Notice: undefined variable... } echo $mijn_var1 . " " . $mijn_var2; // uitvoer: Hello World doe_iets() // functie-aanroep ?> </body> </html>	Dit levert een mooie foutmelding op: Notice: Undefined variable: mijn_var2 in E:\Raymundo\PHP_en_MySQL\PHPscripts\scope1.php on line 16 Klick hier voor een werkend voorbeeld.
<html> <head> <title>Scope van variabelen2</title> </head> <body> <?php // initialisatie: variabelen zichtbaar in globale scope $mijn_var1 = "Hello "; $mijn_var2 = "World!"; function doe_iets() { define("mijn_const", "Brave New "); global $mijn_var1; // $mijn_var1 nu ook bruikbaar binnen functie echo $mijn_var1; // uitvoer: Hello echo mijn_const; } doe_iets(); echo "\n\n\t " . $mijn_var1 . mijn_const . $mijn_var2; ?> </body> </html>	De constante die met define gedefinieerd is, is ook buiten de functie bruikbaar! Maar let op: de escape characters \n en \t worden hier compleet genegeerd (omdat <pre> ontbreekt). Klick hier voor een werkend voorbeeld.
<html> <head> <title>Scope van variabelen</title> </head> <body> <?php // initialisatie: variabelen zichtbaar in globale scope $mijn_var1 = "Hello "; $mijn_var2 = "World!"; function doe_iets() { define("mijn_const", "Brave New "); global $mijn_var1; // $mijn_var1 nu ook bruikbaar binnen functie echo $mijn_var1; // uitvoer: Hello echo mijn_const; } doe_iets(); echo '<pre>'; echo ("\n\t" . $mijn_var1 . mijn_const . $mijn_var2); echo '</pre>'; ?> </body> </html>	Let op: als je gebruik wilt maken van escape characters zoals \n of \t dan moet je wel <pre> en </pre> gebruiken!! Klick hier voor een werkend voorbeeld.

Variabelen die u zelf aanmaakt voldoen altijd aan de scope-regels zoals hierboven werd uitgelegd.
PHP maakt zelf echter ook een groot aantal variabelen, waaronder $_SERVER, $_GET, $_POST, $_REQUEST, $_GLOBAL, $_COOKIES, $_ENV EN $SESSION.
Hierin zijn allerlei omgevingsvariabelen aanwezig en gegevens die bijvoorbeeld via HTML-formulieren aan het script zijn doorgegeven. De inhoud van deze variabelen is atijd en overal te gebruiken. Ze worden dan ook superglobals genoemd.

String- functies

Strings kunnen op verschillende manieren worden gedefinieerd:

binnen enkele aanhalingstekens (snelste methode, er vindt geen evaluatie van variabelen plaats);
binnen dubbele aanhalingstekens (aanwezige variabelen worden eerst geëvalueerd en hun waarden worden ingevuld);

In onderstaande script worden enkele veel gebruikte stringfuncties weergegeven.

<html>
<head>
 <title>Enkele string-functies</title>
</head>

<body>
<?php
/*
* bij de heredoc-syntax kan een string over meerdere regels worden aangegeven
* let op: identifier (EIND) moet als eerste en enige teken op een regel worden aangebracht.
* dus ook geen spaties of tabs!
*/
$mijnstring = <<<EIND
 Voorbeeld van een string
 die over meerdere regels verspreid staat
 en gebruik maakt van de 'heredoc'-notatie.
EIND;
Echo $mijnstring. ' ';

/*
* escape tekens binnen een string:
* \" - toont een dubbel aanhalingsteken
* \' - toont een enkel aanhalingsteken
* \& - toont een ampersand (&)teken
* \$ - toont een dollar teken
* \n - newline
* \t - tab
* \\ - toont backslash teken
*/
$mijnstring = "De backslash wordt ook wel het \"escapeteken\" genoemd";
$vreemde_tekens = "Dollar: \$ \t\tAmpersand: \&\n";
$path = "C:\\Windows\\System\\";
echo $mijnstring . ' ';
echo $vreemde_tekens. ' ';
echo $path. ' ';

// voor \n en \t moeten we wel <pre> gebruiken
echo '<pre>';
echo $vreemde_tekens;
echo '</pre>';

/*
* bij het vergelijken van string mag men gebruik maken van == maar dat kan wel eens tot
* verassende resultaten lijden dus gebruik liever strcmp (), stcasecmp (), strstr (), stristr () of substr ()
*/

if ('Hello World' == 0)
{
 echo 'Hello World evalueert met == dus tot 0' . ' ';
}
else
{
 echo 'Hello World evalueert met == dus NIET tot 0' . ' ';
}

if ('3 bier' == 0)
{
 echo '3 bier evalueert met == dus tot 0' . ' ';
}
else
{
 echo '3 bier evalueert met == dus NIET tot 0' . ' ';
}
/*
* iets beter is het gebruik van de operator ===.
* hierbij wordt ook gekeken of het gegevestypen aan elkaar gelijk zijn.
*/
if ('Hello World' === 0)
{
 echo 'Hello World evalueert met === dus tot 0' . ' ';
}
else
{
 echo 'Hello World evalueert met === dus NIET tot 0' . ' ';
}
/*
* strcmp ($string1, $string2)
* als $string1 < $string2 wordt <0 geretourneerd
* als $string1 > $string2 wordt >0 geretourneerd
* als $string1 = $string2 wordt 0 geretourneerd
*
* bij strcasecmp() wordt GEEN onderscheid gemaakt tussen hoofdletters en kleine letters
*/
echo 'Resultaten van strcmp' . ' ';
echo strcmp("aardbeving" , "bananen") . ' ' ; // resultaat: < 0
echo strcmp("aardbeving" , "Aardbeving") . ' '; // resultaat: > 0
echo strcmp("aardbeving" , "aardbeving") . ' '; // resultaat: 0
echo strcmp("1" , "bananen") . ' ' ; // resultaat: < 0

// niet hoofdlettergevoelig
echo 'Resultaten van strcasecmp' . ' ';
echo strcasecmp("Bananen" , "bananen") . ' ' ; // resultaat: 0

/*
* Om te zoeken binnen een string maakt men gebruikt van strpos(string, gezochte_string)
* Index nummer begint bij 0 (nul)
* strstr() en stristr() zoeken ook naar een substring in een langere zin, maar geven niet de positie van de substring aan maar
* retourneren de rest van de langere zin.
*/
$browser = $_SERVER['HTTP_USER_AGENT'];
$zoekstring = 'MSIE';

if (strpos($browser, $zoekstring))
{
 echo "U gebruikt Internet Explorer" . ' ';
 $positie = strpos($browser, $zoekstring);
 echo "De string: $zoekstring is gevonden op positie: $positie" . ' ';
 echo strstr($browser, $zoekstring). ' ';
}
else
{
 echo "U gebruikt een andere browser". ' ';
}
/*
* Om een substring binnen een string te vervangen kunnen we replace () of substr_replace () aanroepen
*
*/
$mijnstring = 'een, twee, drie, vier vijf';
$zoekstring = 'twee';
$vervangstring = 'zeven';
echo ' ' . str_replace($zoekstring, $vervangstring, $mijnstring) . ' ';
// uitvoer: een, zeven, drie, vier, vijf
?>

</body>
</html>

Werken met Arrays

Array zijn niets meer of minder dan verzamelingen variabelen die onder een gezamelijke naam bereikbaar zijn (de array-naam).
Binnen een array kunt u elk gewenste variabele opslaan. Veel andere programmeer talen kunnen maar één gegevenstype in een array opslaan (array van integers of een array van strings etc), maar in PHP kan elk type gegeven in een array worden opgeslagen.
Zo kan één array bijvoorbeeld bestaan uit drie strings, twee integers, een float en twee andere arrays.

De algemene syntax van een array ziet er als volgt uit:

$arraynaam[index] = 'waarde'

Hierbij is:

$arraynaam de naam van de array;
de waarde index een waarde die evalueert naar een string, of naar een niet negatieve integer. Het wordt ook wel de sleutelwaarde van de array genoemd;
de eigenschap waarde tot slot is de eigenlijke inhoud van dit array-element. De inhoud wordt geassocieerd met de sleutel.

In PHP is het dus mogelijk een array $db te maken waarin de inloggegevens voor een database zijn opgeslagen:

<html>
<head>
<title>PHP - Array met database gegevens </title>
</head>
<body>
<?php
 // een array met strings als index
 $db['host'] = 'localhost';
 $db['user'] = 'root';
 $db['password'] = 'geheim';
 $db['port'] = '3306';
 $db['db_name'] = 'php_app';

 foreach($db as $index => $waarde)
 {
 echo "Arrayindex: $index,
 waarde: $waarde ";
 }

?>
</body>
</html>

Natuurlijk kunnen we ook de 'ouderwetse' integer indices gebruiken zoals hieronder wordt getoond. Let echter op hetvolgende:

als de waarde index (de sleutel van de array) niet is gedefinieerd, zal PHP automatisch een nieuw element met een waarde die één hoger is dan het laatst gedefinieerde element in de array;
als helemaal geen volgnummers is opgegeven, begint een array bij 0 (nul) te tellen.
m.b.v. de functie unset kan een element uit een array verwijderd worden, maar ...... de andere elemeneten schuiven niet automatisch een plaats op!!
Bedenk hierbij dat een array in PHP eigenlijk altijd werkt met sleutels; zo'n nummerieke index is en blijft gewoon een sleutel voor PHP
om een enkele waarde van een array in een string af te drukken moeten we accoladen { } gebruiken.

Hier is een voorbeeld.

<html>
<head>
<title>PHP - Array met huis gegevens </title>
</head>
<body>
<?php
 // een array met integers als index
 $huis[1] = 'woonkamer';
 $huis[2] = 'keuken';
 $huis[3] = 'badkamer';
 $huis[] = 'slaapkamer'; // index wordt automatisch 4
 $huis[] = 'garage'; // index wordt automatisch 5

 foreach($huis as $index => $waarde)
 {
 echo "Arrayindex: $index,
 waarde: $waarde ";
 }
 // elementen uit een array verwijderen gaat met de functie unset
 unset($huis[2]);
 echo " Nadat het tweede array element is verwijderd ";
 foreach($huis as $index => $waarde)
 {
 echo "Arrayindex: $index,
 waarde: $waarde ";
 }
 echo " Nu laten we het systeem helemaal zelf tellen: ";
 $tweede_array[] = 10;
 $tweede_array[] = 20;
 $tweede_array[] = 30;
 $tweede_array[] = 40;
 foreach($tweede_array as $index => $waarde)
 {
 echo "Arrayindex: $index,
 waarde: $waarde ";
 }
 // elementen uit een array verwijderen gaat met de functie unset
 unset($tweede_array[1]);
 echo " Nadat het tweede array element is verwijderd ";
 foreach($tweede_array as $index => $waarde)
 {
 echo "Arrayindex: $index,
 waarde: $waarde ";
 }
 echo "Eerste element van de array is nu: {$tweede_array[0]} ";
 echo "Tweede element van de array is nu: {$tweede_array[1]}";
?>
</body>
</html>

De functie array ( )

In plaats van de hiervoor gebruikte notatie kan ook de PHP-functie array( ) worden gebruikt.
De index/waardeparen worden dan met de operator => aangegeven

Hier is een voorbeeld.

<html>
<head>
<title>PHP - Functie Array() met huis gegevens </title>
</head>
<body>
<?php
 // een array via de functie array()
 $huis = array( 1 =>'woonkamer',
 2 =>'keuken',
 3 =>'badkamer',
 'slaapkamer1',
 'garage'
 );

 foreach($huis as $index => $waarde)
 {
 echo "Arrayindex: $index,
 waarde: $waarde ";
 }

 // een array via de functie array(), maar nu zijn géén sleutels opgegeven
 // systeem begint dan automatisch te tellen vanaf 0 (nul)
 $huis = array('woonkamer',
 'keuken',
 'badkamer',
 'slaapkamer',
 'garage'
 );

 echo " ";
 foreach($huis as $index => $waarde)
 {
 echo "Arrayindex: $index,
 waarde: $waarde ";
 }

?>
</body>
</html>

Meerdimensionale arrays

Elk element van een array kan desgewenst zelf ook weer een array zijn (een subarray als het ware).
Zo zijn meer dimensionale arrays te maken. De inhoud van de subarray is bereikbaar via een extra hakenpaar.
Hier is een voorbeeld.

<html>
<head>
<title>PHP - Meer dimensionale Array</title>
</head>
<body>
<?php
 // een array via de functie array()
 $rij1 = array(1 =>10,
 2 =>20,
 3 =>30
 );
 $rij2 = array(1 =>40,
 2 =>50,
 3 =>60
 );
 $rij3 = array(1 =>70,
 2 =>80,
 3 =>90
 );
/* Dit geeft foutmeldingen:Undefined offset: 2 in meerdimensionale_array1.php on line 43

 $matrix1 [1][1] = $rij1;
 $matrix1 [2][1] = $rij2;
 $matrix1 [3][1] = $rij3;
*/
 $matrix1 [1] = $rij1;
 $matrix1 [2] = $rij2;
 $matrix1 [3] = $rij3;

 echo "{$matrix1[1][2]} ";

 foreach($matrix1 as $index => $waarde)
 {
 echo "Arrayindex: $index,
 waarde: $waarde ";
 }

 for($i = 1; $i <=3; $i++)
 {
 for($j = 1; $j <=3; $j++)
 {
 echo "{$matrix1[$i][$j]} "; // om de inhoud van een array aan te geven binnen een string moet { } gebruikt worden!
 }
 echo " ";
 }

 // een meerdimensionale array via de functie array()
 $matrix2 = array(1=> $rij1, 2=> $rij2, 3=> $rij3);

 echo " ";
 foreach($matrix2 as $index => $waarde)
 {
 echo "Arrayindex: $index,
 waarde: {$waarde} ";
 }
 for($i = 1; $i <=3; $i++)
 {
 for($j = 1; $j <=3; $j++)
 {
 echo "{$matrix1[$i][$j]} ";
 }
 echo " ";
 }
?>
</body>
</html>

Var_dump arrays

Als u aan een array elementen hebt toegevoegd van verschillende typen, kan de functie var_dump handig zijn om te zien welk type ieder element heeft:
Hier is een voorbeeld.

<html>
<head>
<title>PHP - Var_dump van een Array</title>
</head>
<body>
<h3>HTTP Server Vars</h3><table>
<table border=1>
<?php
//server vars.php

// foreach ($HTTP_SERVER_VARS as $sleutel => $var)
foreach ($_SERVER as $sleutel => $var)
{
 echo "<tr>";
 echo "<td>$sleutel</td>";
 echo "<td>$var</td>";
 echo "</tr>";
}

echo '<pre>';
var_dump($_SERVER);
echo '</pre>';

?>
</table>
</body>
</html>

Commentaar in PHP

Men kan op drie manieren commentaar opnemen in PHP scripts:
// commentaar op een regel tot aan het einde van de regel;
# commentaar op een regel tot aan het einde van de regel;
/*
blok commentaar, over verschillende regels.
*/

Foutmeldingen in PHP

In het bestand php.ini kan aangegeven worden in welke mate foutmeldingen getoond moeten worden.

Keyword	Waarde	Effect
error_reporting	E_ALL	Toon alle foutmeldingen
	E_ERROR	Toon allleen errors
	E_WARNING	Toon waarschuwingen
	E_STRICT	Waarschuw bij niet-gedefinieerde variabelen en andere tips om uw code te optimaliseren

Databases

Een database bestaat in feite uit verschillende tabellen. Zodra er twee of meer tabellen aanwezig zijn, kunnen relaties tussen de tabellen worden gelegd.
Elke tabel bestaat uit records. Deze records bevatten de uiteindelijke gegevens.
Elke record binnen een tabel heeft dezelfde indeling (velden).

Gegevens die in een database zijn opgeslagen moet u er op de een of andere manier ook weer uit tevoorschijn kunnen toveren. Hiervoor wordt vaak gebruik gemaakt van SQL. Dit is een soort Esperanto voor databases.
Door in SQL een vraag te stellen krijgt u gegevens terug in de vorm van een array. Dit wordt een recordset of resultset genoemd.

Het stellen van een dergelijke vraag wordt in SQL een query genoemd.
Veel databases ondersteunen de opslag van query's rechtstreeks in het DBMS. In Microsoft SQL Server heten dit dan stored procedures.
Stored procedures worden in MySQL vanaf versie 5 ondersteund.

Database beheertool phpMyAdmin

Bij de Wamp installatie wordt ook de phpMyAdmin database beheertool geïnstalleerd.

Deze is op te starten via de icon-tray:

Met deze tool kunnen de zelf gemaakte databases worden beheerd, maar ook de systeem database mysql.
In deze systeem database kunnen verschillende algemene variabelen worden ingesteld zoals:

root password en privileges
user password en privileges

Default locatie van een MySQL-database wijzigen

Default worden de databases die men met MySQL aanmaakt geplaatst in de directory:
D:\wamp\bin\mysql\mysql5.1.36\data\ ; waarbij D: de gekozen installatie schijf is.

Per database wordt een nieuwe subdirectory aangemaakt.

Om deze default locatie te wijzigen moet men het bestand D:\wamp\bin\mysql\mysql5.1.36\my.ini editen.

# The following options will be passed to all MySQL clients
[client]
#password    = your_password
port        = 3306
socket        = /tmp/mysql.sock

# Here follows entries for some specific programs

# The MySQL server
[wampmysqld]
port        = 3306
socket        = /tmp/mysql.sock
skip-locking
key_buffer = 16M
max_allowed_packet = 1M
table_cache = 64
sort_buffer_size = 512K
net_buffer_length = 8K
read_buffer_size = 256K
read_rnd_buffer_size = 512K
myisam_sort_buffer_size = 8M
basedir=D:/wamp/bin/mysql/mysql5.1.36
log-error=D:/wamp/logs/mysql.log
#
# Veranderd door Raymundo
#
# datadir=D:/wamp/bin/mysql/mysql5.1.36/data
datadir=E:/Raymundo/PHP_en_MySQL/Databases
.
.
.
.

Hier kan dus ook een password aangepast/'ge-set' worden, maar ik heb geen flauw idee waar deze voor gebruikt wordt. Root en gebruiker password kan beter via phpMyAdmin in de database mysql worden aangebracht/gewijzigd (tabel user).

Verander de variabele datadir naar de gewenste locatie.

Let op de forward / i.p.v. de bachward \

Root password in MySQL

Default staat er geen password voor de gebruiker root ingesteld. Dit is schijnbaar onveilig, want elke keer als phpMyAdmin opgestart wordt verschijnt er een waarschuwing:

Uw configuratie bestand bevat instellingen (root zonder wachtwoord) die betrekking hebben tot het standaard MySQL account. Uw MySQL-server draait met deze standaard waardes, en is open voor ongewilde toegang. Het wordt dus aangeraden dit op te lossen.

Dus hoog tijd om een password aan te brengen ..... maar hoe??

User password in MySQL

User (en in feite ook root) password kunnen het beste via phpMyAdmin worden aangebracht.
Hiertoe wordt de tabel user in de database mysql aangepast (musql is dus de naam van een systeemdatabase!).

Enkele tabellen in de systeem database van MySQL. Eén daarvan is user, hierin wordt de rootpassword aangebracht!

De tabel user in de systeem database van MySQL

Zoals hier boven te zien is staan default root op localhost en root op 127.0.0.1 beide zonder password!
Via de knop wijzig (

) kunnen de eigenschappen zoals password en Select privelage worden aangepast.

Vergeet hierbij niet om in kolom Functie te kiezen voor 'password'; hiermee geeft u opdracht het password te vercijferen.

Via deze tabel kunnen verschillende gebruikers worden aangemaakt met verschillende gebruikers-privileges.

Zo is user raho aangemaakt (piet!)

Uitloggen phpMyAdmin

Alternatief: via dosbox

Open een dos-box (cmd-window) en type daarin het volgende commando:

D:\wamp\bin\mysql\mysql5.1.36\bin>mysqladmin -u root password raho_MySQL

Helaas krijg ik nu bij het opstarten van phpMyAdmin de volgende foutmelding:

Password invoeren bij opstarten phpMyAdmin

Het bestand config.inc.php is te vinden in de directory: D:\wamp\apps\phpmyadmin3.2.0.1

<?php

/* Servers configuration */
$i = 0;

/* Server: localhost [1] */
$i++;
$cfg['Servers'][$i]['verbose'] = 'localhost';
$cfg['Servers'][$i]['host'] = 'localhost';
$cfg['Servers'][$i]['port'] = '';
$cfg['Servers'][$i]['socket'] = '';
$cfg['Servers'][$i]['connect_type'] = 'tcp';
$cfg['Servers'][$i]['extension'] = 'mysqli';
$cfg['Servers'][$i]['auth_type'] = 'HTTP';
$cfg['Servers'][$i]['user'] = 'root';
$cfg['Servers'][$i]['password'] = '';
$cfg['Servers'][$i]['AllowNoPassword'] = true;

/* End of servers configuration */

$cfg['DefaultLang'] = 'en-utf-8';
$cfg['ServerDefault'] = 1;
$cfg['UploadDir'] = '';
$cfg['SaveDir'] = '';

?>

Hier kiezen we al authentication type: HTTP ; dit zorgt ervoor dat phpMyAdmin niet zomaar opgestart kan worden

Let op: dit bestand is duidelijk in Unix formaat dus niet editen met Notepad, gebruik bijv. PFE 32 of Notepad++

Problemen bij het aanmaken van user raho in MySQL-database

1 row(s) inserted.
Warning: #1364 Field 'ssl_cipher' doesn't have a default value
Warning: #1364 Field 'x509_issuer' doesn't have a default value
Warning: #1364 Field 'x509_subject' doesn't have a default value

Zorg ervoor dat het password vercijferd wordt opgeslagen.!

Een MySQL-database maken en gebruiken

CREATE DATABASE 'naam';
USE naam;

De opdracht create database is de SQL-notatie voor het maken van een database. Met de opdracht use geeft u MySQL vervolgens de opdracht om deze database te activeren voor de huidige sessie.

Opdrachten voor databaseonderhoud

CREATE TABLE tabelnaam	Maak een tabel binnen de database die met USE is geselecteerd
DESCRIBE tabelnaam	Geef een overzicht van de structuur (veldnamen en typen) van de aangegeven tabel
SHOW DATABASES	Laat zien welke databases op de MySQL-server aanwezig zijn
SHOW TABLES	Laata zien welke tabellen in de huidige actieve database aanwezig zijn
DROP TABLE tabelnaam	Verwijder de aangegeven tabel. Let op: weg = pech
DROP DATABASE dbnaam	Verwijder de aangegeven database!!

Start phpMyAdmin
Activeer de tab SQL en toets de SQL commando's in. Let op de backslach quotes.
Als alles goed gegaan is, is de net aangemaakte database in de linkerrij zichtbaar.

Vervolgens gaan we in de net aangemaakte database twee tabellen aanmaken.

Let op: Het is noodzakelijk dat eerst de gewenste database in het linker venster geselecteerd wordt!! DROP TABLE IF EXISTS `medewerkers`; CREATE TABLE `medewerkers` ( `med_id` int(10) unsigned NOT NULL auto_increment, `med_voornaam` varchar(45) NOT NULL default '', `med_achternaam` varchar(45) NOT NULL default '', `med_email` varchar(45) default NULL, `med_geboren` date NOT NULL default '0000-00-00', `med_afdeling` tinyint(3) unsigned NOT NULL default '1', PRIMARY KEY (`med_id`) ) ENGINE=InnoDB DEFAULT CHARSET=latin1 AUTO_INCREMENT=1 ;
Als alles goed gegaan is geeft phpMyAdmin een melding zoals hiernaast te zien is. Het engine-type InniDB is een speciaal tabeltype waarmee het mogelijk wordt een transactiegebaseerde database te maken.. Bij een transactie worden meerdere opdrachten ale één groep uitgevoerd. Bijv: bij het bestellen van kaarten controleer of de gebruiker is ingelogd; controleer of er voldoende plaatsen beschikbaar zijn; controleer of het bedrag van de creditkaart kan worden afgeschreven; druk de benodigde kaarten af met de gegeven van deze gebruiker; verminder het aantal beschikbare plaatsen met het bestelde aantal. Als één van deze acties niet correct verloopt, worden alle overige statements in de groep teruggedraaid (rolllback). Alles alle deelopdrachten naar tevredenheid zijn doorlopen wordt de transactie als geheel doorgevoerd (commit). Let wel: tabeltype MyISAM is nog steeds beschikbaar, maar kan niet gebruikt worden voor transacties!
Als voorbeeld van een SELECT commando: SELECT * FROM afdeling
SELECT med_voornaam, med_achternaam, med_afdeling FROM medewerkers WHERE med_afdeling = '1' ; De opdracht LIMIT wordt automatisch door phpMyAdmin toegevoegd. LIMIT a, b: toon b records beginnend bij record a+1 ( de eerste a records worden dus niet getoond!) Een willekeurige record selecteren kan met de rand functie in combinatie met LIMIT 1: SELECT med_id, med_voornaam, med_achternaam FROM medewerkers ORDER BY RAND ( ) LI.MIT 1;
Let op CONCATENATIE werkt in MySQL anders dan verwacht: NIET met \|\| maar met de functie CONCAT Bij Alias mag keyword AS gebruikt worden, dit is echter niet verplicht.

Enkele veel gebruikte veldtypes in MySQL

int	Een geheel getal van 4 bytes
tinyint	Een geheel getal van 1 byte
varchar	Een string van variabele lente met maximaal 255 tekens.
text	Een string van variabele lengte van maximaal 65.535 tekens
date	Een datum in het formaat jjjj-mm-dd
datetime	Een datum waarbinnen ook tijdinformatie is opgeslagen. Het formaat is dan jjjj-mm-dd hh:mm:ss

Een eenvoudige join

MySQL opdrachten via PHP

Voor het gebruik van MySQL vanuit PHP wordt altijd een vaste volgorde doorlopen:

Maak contact met de database server;
mysqli_connect( )
Selecteer de juiste database;
mysqli_select_db( )
Stel een SQL-query op en biedt deze aan de database aan;
mysqli_query( )
Verwerk de resultaten van de query in een webpagina;
mysqli_fetch_array( )
Sluit de databaseverbinding.
mysqli_close( )

In onderstaande script wordt een en ander aangetoond:

<html>
<head>
 <title>Verbinding maken met MySQL</title>
</head>

<body>
<?php
// initialisatie
$host = 'localhost';
$gebruiker = 'root';
$wachtwoord = '';
$database = 'Ray1';
$query = 'SELECT * FROM medewerkers';
// stap 1) verbinding tot stand brengen
if ($db = mysqli_connect($host, $gebruiker, $wachtwoord))
{
 echo "Stap 1) De verbinding met MySQL - $host is geslaagd.";
 echo "Ingelogd als: $gebruiker ";
}
else
{
 echo "FOUT: De verbinding met MySQL kan niet tot stand worden gebracht";
 exit;
}

// stap 2) controleren of de database geopend kan worden
if (mysqli_select_db($db, $database))
{
 echo "Stap 2) Database geselecteerd: $database ";
}
else
{
 echo "FOUT: De database $database kon niet worden geopend";
 exit;
}

// stap 3) de query uitvoeren
if ($result = mysqli_query($db, $query))
{
 echo "Stap 3) De query \"$query\" is met succes uitgevoerd ";
}
else
{
 echo "FOUT: er is een fout opgetreden bij het uitvoeren van de query $query";
 exit;
}

// stap 4) de resultaten naar het scherm schrijven
echo "<h2>Stap 4) inhoud:</h2>";
while ($rij = mysqli_fetch_array($result))
{
 echo "medewerker {$rij['med_id']} :
 {$rij['med_voornaam']} {$rij['med_achternaam']} ";
}

// stap 5) verbinding met de database sluiten
if(mysqli_close($db))
{
 echo " Stap 5) verbinding met database gesloten";
}
else
{
 echo "FOUT: de verbinding met de database kon niet worden gesloten";
 exit;
}
?>
</body>
</html>

Stap 1) De verbinding met MySQL - localhost is geslaagd.Ingelogd als: root
Stap 2) Database geselecteerd: Ray1
FOUT: er is een fout opgetreden bij het uitvoeren van de query SELECT * FROM medewerkers