PHP tutvustus.

	Tutvustavate ja harva muutuva teabega veebilehtede puhul saab hakkama, kui kord leheküljed valmis teha ning lugejate jaoks nähtavasse kohta välja riputada. Lehti annab illustreerida kõigega, mille näitamisega brauserid hakkama saavad, alates lihtsast alljoonimisest ja kirja värvi muutmisest kuni ilusate piltide ja videoteni välja. Veebiserver lihtsalt saadab kasutaja päringu peale andmeid välja ning kui lehe koostaja kavad ning brauseri võimalused kokku lähevad, siis peaks tulemus ilus ja kasulik olema. Andmete muutumisel tuleb lehtedesse muutused sisse viia.  Ka kasutaja tegevusele annab brauseris reageerida. Javaskriptis on pea kõik programmeerimiskeelte juurde kuuluv vajalik olemas ning kasutaja andmete põhjal talle tulemusi arvutada pole tehnilise poole pealt kuigi suur probleem. Levinumad graafilised brauserid saavad selle keele käskude interpreteerimisega enamvähem rahuldavalt toime. Javaskript aga peab üldjuhul piirduma juba lehe avamisel kaasa tulnud (vajadusel kasutaja eest varjatud) andmetega. Ühelt kasutajalt teiseni selle abil naljalt midagi ei jõua. Samuti pole mõistlik Javaskripti kasutada juhul, kui ekraanile on vaja manada vaid pisikest, kasutaja poolt soovitud osa suurest andmehulgast. Standarditest hoolimata ei tööta Javaskript kõigis brauserites ühtmoodi ning mõnel pool puudub sootuks. Alternatiivina tuleb sel juhul lehed koostada serveris vastava programmi abil. 
	Serveris lehtede koostamisega kaasneb hulgaliselt nii häid kui halbu omadusi. Head tulevad enamasti ühilduvuse ning andmevahetuse poolelt, halvaks saab pidada suuremaid nõudeid veebiserverile ja turvaprobleeme. Tehnilise poole pealt: staatilisi lehti näidates kopeeritakse nende sisu lihtsalt võrku, veebiserveris koostades aga käivitatakse iga lehe puhul programm, mille väljund saadetakse kasutaja brauserisse. Põhimõtteliselt saab selliseid programme kirjutada pea iga keele abil, mõnele keelele on lihtsalt loodud juurde vahendeid, mille abil veebile sobival kujul andmete loomist lihtsustada. Üheksakümnendate algul olid selle tarvis levinumateks keelteks C ja Perl, ajapikku on lisandunud hulga vahendeid ja teeke: Java servletid ja JSP, Javaskripti veebivahendid, Active Server Pages Visual Basicu baasil. PHP loomisel on kohe algusest lähtutud veebi vajadustest, keel ise sarnaneb mitmes mõttes Perliga. 

Väike näide

	Lihtsam tervitus selleks keeles oleks	

<?php
 echo "Tere";
?>

	Leidub tegelikult ka veel kergem moodus andmete väljundisse saatmiseks. Kui on veebiserveris php-programmiks kuulutatud fail, mis sisaldab vaid tavalist (HTML) teksti ning kus pole koodiosa alguse 
<?php
ning lõpu
 ?>
märke, siis väljastatakse failis olev tekst lihtsalt väljundisse ilma mingit koodi käivitamata.

Muutujad, sõned

	Tahtes andmeid vahepeal mälus hoida, tuleb kasutada muutujaid. Muutuja puhul antakse andmetele nimi (alljärgnevas näites s) ning edaspidi saab selle nime järgi taas sinna pandu kätte. Muutuja nime ees on dollarimärk $.

<html><body>
 <?php
  $s="Tavaline tekst";
  echo $s;
 ?>
</body></html>

	Muutujast võib väärtust küsida nii mitu korda kui soovid:

<html><body>
 <?php
  $s="Tavaline tekst ";
  echo $s;
  echo $s;
 ?>
</body></html>

	Et PHP on mõeldud veebi tarbeks, kus tuleb mõnikord ka veidi pikemaid tekste koodist välja kirjutada, siis on siin võimalik kirjutada mitmerealist teksti ilma, et peaks selle jaoks erimärke kasutama. Nii tuleb aga teksti algusesse ja lõppu panna ülakomad. Tahtes aga sellise teksti sisse paigutada samuti ülakomasid kirjutada, tuleb nende ette panna langjoon \. Võrreldes teiste keeltega polegi selline mitmele reale kirjutamise võimalus päris tavapärane, kuid teeb veebilehtede loomise pikema teksti korral tuntavalt mugavamaks. All näites on väljatrükitav tekst pandud HTML-i pre-siltide vahele, et oleks ekraanil näha, kus reavahetused asuvad. Vaikimisi HTML-i lähtekoodis oleva teksti paigutus lehekülje välimust ei mõjuta, reavahetuseks on hoopis silt <br>.

<html><body><pre>
 <?php
   $m='Mitmerealine
       tekst koos
       \'ülakoma\'dega';
   echo $m;
 ?>
</pre></body></html>

	Kui soovida muutuja väärtust teksti sisse paigutada, tuleb lihtsalt muutuja nimi koos enese ees oleva dollariga tekstis sobivale kohale panna. Tahtes aga loodavas lauses midagi arvutada, sel juhul on tarvis kasutada pikemat võimalust, kus tekst liidetakse mitmest osast kokku. Sidurdusmärk punkt ühendab tema mõlemal pool olevad andmed tekstidena kokku. Loomulikult annab ka tavalise muutuja väärtust sidurdamise abil lause keskele viia, kirjapilt oleks siis:

$s="Ta oli kunagi ".$vanus." aastane";

<html><body>
 <?php
  $vanus=9;
  $s="Ta oli kunagi $vanus aastane. ";
  echo $s;
  echo "Nüüd on ta \n" . ($vanus+1) . " aastane"
  // \n tähistab reavahetust. Näha HTML koodis. 
 ?>
</body></html>

	Kui me ei soovi, et pärast muutuja väärtust tuleks lausesse tühik või muu sümbol, mille järgi intepretaator suudab otsustada, kus muutuja nimi lõpeb ning kust läheb edasi tavaline tekst, sellisel juhul tuleb dollari taga olev muutuja nimi panna loogeliste sulgude sisse. 

<html><body>
 <?php
  $koht="palli";
  echo "Ta jooksis ${koht}ni";
 ?>
</body></html>

	Sõltuvalt veebiserveri konfiguratsioonist võib PHP koodi alustamise/lõpetamise märke olla mitmesuguseid. Kui meie arendusvahend nõuab, et koostatav kood peab vastama XHTML-standardile (HTML-tekst, mis vastab XML-i nõuetele), sellisel juhul loetakse tekst "<?php" vigaseks ning tuleb teisiti teada anda, milline osa andmetest on käivitatav kood.

<html><body>
<script language="php">
 echo ("Teretus!");
</script>
</body>
</html>

Tsüklid

	Harilikuks teksti välja trükkimiseks pole vaja programmi kasutada. Programmide ja masina eelised tulevad esile alles siis, kui sama tööd on vaja korduvalt teha. Mingit operatsiooni kümme korda teha pole veebiserverile mingi probleem. Programmeerimiskeeltes on tegevuse kordamiseks loodud tsüklid. Eelkontrolliga silmuse puhul kontrollitakse igal korral enne sinna sisenemist, kas seal olevaid käske üldse täita vaja on. Pärast vastava ploki läbimist minnakse taas ploki algusesse vaatama, kas läbitud tegevust oleks vaja korrata.  Kui soovin, et programm väljastaks kümme loetelu elementi, siis pean lugema, mitmenda elemendiga tegemist on, et teaks õigel ajal kirjutamise lõpetada. Kui hakata ühe käsu kaupa programmi tööd vaatama, siis alatest koodi algusest <?php juurest:

•	Antakse muutujale $nr väärtuseks 0.
•	Kontrollitakse, kas $nr väärtus on väiksem kui 10. Kuna tingimus on tõene (sest me just ise andsime sinna väärtuseks nulli), siis sisenetakse looksulgudega ümbritsetud plokki.
•	Kirjutatakse välja tekst <li>Number 0</li>
•	Omistatakse muutujale $nr endisest ühe võrra suurem väärtus. 
•	Minnakse ploki algusse kontrollima, kas on vaja sellesse siseneda
•	Uuritakse, kas muutuja väärtus on väiksem kümnest. Olgugi, et nulli asemel on nüüd üks, on see ikkagi väiksem kümnest. Tingimus tõene ning sisenetakse plokki.
•	Kirjutatakse välja loetelu järgmine element.
•	Suurendatakse taas muutuja väärtust, sedakorda ühest kaheni. 
•	Minnakse taas ploki algusse kontrollima. 
•	Ka kaks on kümnest väikem, seetõttu jätkatakse kordust.
•	...
•	Kirjutatakse välja <li>Number 9</li>
•	Suurendakse $nr'i üheksalt kümnele. 
•	Minnakse taas ploki algusse kontrollima. 
•	Tingimus "kas kümme on väiksem kümnest" on väär. Seetõttu plokki enam ei siseneta ning jätkatakse tööd koodirealt, mis järgneb plokile. 
•	Et järgnevalt tuleb koodi lõputunnus "?>", siis rohkem käske täita pole ning edasi lihtsalt jätkatakse järgneva teksti saatmist väljundisse.

<html>
  <body>
   <ul>
    <?php
     $nr=0;
     while($nr<10){
       echo "    <li>Number $nr</li>";
       $nr=$nr+1;
     } 
    ?>
   </ul>
  </body>
</html>

while-tsükliga annab koodi sisse kirjutada kõik kordused, mis seal peaks vaja olema. Kuna küllalt sageli tuleb koostada kordusi, kus loendurile antakse algväärtus, kontrollitakse iga sammu algul jätkamise vajadust ning sammu lõpus on vaja loendurit suurendada, siis selle jaoks on mitmesse keelde loodud tsükli kirjutamiseks lühem kuju: for. Toimimine aga täpselt sama, kui eelmisel juhul. Reavahetusmärk \n väljatrükitava rea lõpus hoolitseb, et ka väljastatavas HTML-i lähtekoodis mindaks uue elemendiga järgmisele reale. Ekraanil paistval lehel vahet ei ole, kuid loodud HTML-i on lihtsam ja ülevaatlikum lugeda.

<html>
  <body>
   <ul>
    <?php
     for($nr=0; $nr<10; $nr++){
       echo "    <li>Number $nr</li>\n";
     } 
    ?>
   </ul>
  </body>
</html>

Loodud veebilehe kood näeb välja:

<html>
  <body>
   <ul>
        <li>Number 0</li>
    <li>Number 1</li>
    <li>Number 2</li>
    <li>Number 3</li>
    <li>Number 4</li>
    <li>Number 5</li>
    <li>Number 6</li>
    <li>Number 7</li>
    <li>Number 8</li>
    <li>Number 9</li>
   </ul>
  </body>
</html>

	Harvadel juhtudel eelistatakse jätkamise vajalikkust kontrollida tsükli lõpus. Kõike saab teha algse eelkontrolliga while-tsükliga, kuid ei tasu ehmatada, kui ettejuhtuvas koodis on kontroll ploki lõpus. Sellist kordust läheb enamasti vaja, kui samm tuleb ühel korral igal juhul läbida (näiteks andmete küsimine) ning tegevus läheb kordamisel vaid juhul, kui esimesel korral midagi nihu läks.

<html>
  <body>
   <ul>
    <?php
     $nr=0;
     do {
       echo "    <li>Number $nr</li>";
       $nr=$nr+1;
     } while($nr<10)
    ?>
   </ul>
  </body>
</html>

Valikud

	Teiseks tähtsamaks vahendiks käsujada juhtimisel on võimalus osa käske vahele jätta. All näites teatatakse vanusevahe vaid juhul, kui Mari jukust noorem on.

<html><body>
 <?php
  $marivanus=13;
  $jukuvanus=14;
  if($marivanus<$jukuvanus){
    echo "Mari on noorem kui Juku";
  }
 ?>
</body></html>

	Kui soovida ka teistpidisele juhule reageerida, sel juhul tuleb tingimuslausele lisada teine pool nimega else. 

<html><body>
 <?php
  $marivanus=13;
  $jukuvanus=14;
  if($marivanus<$jukuvanus){
    echo "Mari on noorem kui Juku";
  } else {
    echo "Mari pole noorem kui Juku";
  }
 ?>
</body></html>

	Soovides kontrollida, kas vanus on väiksem või võrdne, tuleb lihtsalt vahele kirjutada märk "<=".

<html><body>
 <?php
  $marivanus=13;
  $jukuvanus=14;
  if($marivanus<=$jukuvanus){
    echo "Mari on Juku vanune või noorem";
  } else {
    echo "Mari peab olema Jukust vanem";
  }
 ?>
</body></html>

	Mõnikord soovitakse tingimus lühemalt ja lause sisse kirja panna. Selliseks puhuks on loodud ternaarne operaator (koosneb kolmest osast). Esimeses on tingimus, teises on käitumine/vastus tingimuse tõese väärtuse puhul, kolmandas väära väärtuse puhul. Tingimust eraldab küsimärk, vastuseid koolon.

<html><body>
 <?php
  $marivanus=13;
  $jukuvanus=14;
  echo "Mari ". (($marivanus<$jukuvanus) ? "on" : "pole").
       " noorem kui Juku";
 ?>
</body></html>

	Võrdluse tulemuse saab muutujasse meelde jätta. Sellisel juhul saab tulemust tulevikus ning soovi korral ka mitmes kohas kasutada. Tõeväärtusmuutujat läheb vaja ka siis, kui soovime hulga andmeid läbi kontrollida ning uurida, et kas vähemalt kusagilt leiti õige vastus.

<html><body>
 <?php
  $marivanus=15;
  $jukuvanus=14;
  $mariOnNoorem=($marivanus<$jukuvanus);
  if($mariOnNoorem){
    echo "Mari on Juku vanune või noorem";
  } else {
    echo "Mari peab olema Jukust vanem";
  }
 ?>
</body></html>

	Mõnikord testimise ajal soovime, et igal juhul täidetaks käsud, mis on harus, kuhu sisenetakse tõese tingimuse puhul. Seda näiteks juhul, kui soovime vastavaid käske katsetada, pole aga alati jaksu sisestada algandmeid, mis viivad soovitud harusse. Sellisel juhul võime tingimuse kohale kirjutada tõeväärtuskonstandi “true”. Ka avaldis ju arvutatakse lõpuks taolisele kujule. 

<html><body>
 <?php
   if(true){
     echo "Tingimus on tõene";
   } else {
     echo "Tingimus on väär";
   }
 ?>
</body></html>

	Eeltooduga samaväärne on alatiselt tõene võrdus, näiteks kas arv üks on võrdne ühega. 

<html><body>
 <?php
   if(1==1){
     echo "Tingimus on tõene";
   } else {
     echo "Tingimus on väär";
   }
 ?>
</body></html>

	Mittevõrdsuse kontrolliks on järjestikku pandud hüüumärk ja võrdusmärk. 

<html><body>
 <?php
   if(3!=2){
     echo "Tingimus on tõene";
   } else {
     echo "Tingimus on väär";
   }
 ?>
</body></html>

	Rohkemate valikute puhuks on loodud switch ja case käskudest koosnev lause. Kuigi kõik valimised saab ka if ja else käskudega läbi ajada, õnnestub niimoodi mõnikord tegevus lühemalt kirja panna. Sobiva case korral jätkatakse käskude täitmist kuni järgmise break’ini. 

<html><body>
  <?php
   $vanus=9;
   $vastus="tundmatu vanus";
   switch($vanus){
     case  8: $vastus="noor";  break;
     case  9: $vastus="paras"; break;
     case 10: $vastus="vana";  break;
   }
   echo "Tulemus: " . $vastus;
  ?>
</body></html>

	Järgnevas näites küsitakse kasutajalt vanus ning vastavalt sellele teatatakse arvamus tema vanuse kohta. Lehe esimesel avamisel on vanus tundmatu, sest kasutaja pole saanud sellesse midagi kirjutada. Lehele ilmub tekstiväli. Kui sellesse midagi kirjutada ning sisestusklahvi vajutada, siis laetakse sama leht, kusjuures tekstivälja kirjutatu jõuab lehe programmi koodi tekstiväljaga samanimelise muutuja koosseisus. Kui näiteks kirjutasin tekstivälja numbri kaheksa, siis on pärast lehele jõudmist selles kasutada muutuja $vanus väärtusega 8. Kui kirjutanuks 7, sel juhul tulnuks vastuseks “liiga noor”, sest seitsme järel pole käsklust break nin sujuvalt võetakse ette ka kaheksale vastav käsk. Kuna selleks on $vastus.="noor"; ehk muutuja vastus väärtusele liidetakse sõna “noor” (.= tähistab algsele juurde liitmist, pikemalt kirjutatuna $vastus=$vastus."noor";). 

<html><body>
  <?php
   $vastus="";
   switch($vanus){
     case  7: $vastus="liiga ";
     case  8: $vastus.="noor";  break;
     case  9: $vastus="paras"; break;
     case 10: $vastus="vana";  break;
     default: $vastus="tundmatu vanus";
   }
   echo "Tulemus: " . $vastus;
  ?>
  <p>
  Sisesta vanus
  <form>
    <input type="text" name="vanus">
  </form>
  </p>
</body></html>

Andmebaasiühendus.

Eelpooltoodud tulemused on võimalik saavutada ka veebiserveri programmeerimiseks õigusi omamata, luues sarnased lõigud Javaskriptis ning pannes koodi tööle kliendi arvutis. Tahtes aga suuremate andmehulkadega tegeleda ning ühe kasutaja sisestatud andmeid teisele näidata, peab olema serveris koht kus ning vahend kuidas neid talletada ning pärast jälle kätte saada. Iseenesest on võimalik andmeid hoida tekstifailis, mis ehk algselt programmeerijatele lihtsam tundub, kuid vähegi suuremate andmehulkade ning rohkem kui ühe kasutaja puhul pääseme andmebaasi teenuseid kasutades mitmest murest, mis meid muidu tekstifaili puhul häiriksid. PHP-ga kasutatakse sageli koos MySQL-i nimelist andmebaasi, kuna see on samuti vabalt levitatav ja küllalt kergesti kasutatav nagu PHP-gi. Iseenesest aga annab vastavate draiverite olemasolul kas siis otse või ODBC kaudu ühendada PHP-d mis tahes andmebaasidega. Käske antakse andmebaasile SQL-lausetena, millest põhilised langevad eri andmebaside puhul üldjoontes kokku. 
Kaasajal levinumas, relatsioonilises, andmemudelis esitatakse kõik andmed tabelitena, nendes read ja veerud nagu tabelites ikka. Järgnevas näites ühendatakse end kohalikus masinas jooksva MySQL’i külge. Nimi localhost tähendab kohalikku masinat, juku on kasutajanimi ning kala parool selle kasutaja jaoks. Järgmise käsuga valitakse, millise nimega andmebaasiga tegeleda soovitakse. Ühe andmebaasiohjuri (nt. MySQL-i) küljes võib olla mitu andmebaasi (siin on üheks neist juku1), igas baasis mitu tabelit (siin saab tabeli nimeks teated0) ning igas tabelis hulk ridu ja veerge (siin loodakse tabel ühe veeruga mil nimeks teade ning ridu veel pole, sest andmeid pole sisestatud). Pärast andmebaasimootori teenuste kasutamise lõppu on viisakas anda ressursside vabastamiseks käsklus mysql_close().

<html><body>
 <?php
   mysql_connect("localhost", "juku", "kala");
   mysql_select_db("juku1");
   mysql_query("CREATE TABLE teated0 (teade TEXT)");
   mysql_close();
 ?>
</body></html>

	Sageli on ühe andmebaasiga seotud mitu PHP-lehte. Sellisel juhul pole otstarbekas mitte igasse neist kopeerida andmebaasimootoriga ühendamiseks vajalikke andmeid, vaid tuleks vähemasti kasutajanimi ja parool, soovitavalt aga ka masina ja baasi nimi kirjutada eraldi asuvasse konfiguratsioonifaili. Sellisel juhul on andmete muutumisel kergem need ühes kohas kindlaks määrata. Samuti on parool kirjas vaid ühes kohas ning oht, et kogemata kopeerides see võõrastele silmadele nähtavaks osutub, väiksem. Samuti on võimalik selline konfiguratsioonifail paigutada eraldi kataloogi, et see mõne muu apsaka tõttu veebis nähtavaks ei muutuks. Käsuga require saab faili andmed programmi sisse lugeda.
	All näites luuakse veidi keerulisem tabel. Seal on kaks veergu. Teine nagu ennist tekstilise teate sisestamiseks, esimene aga automaatsuurenev number, mis igale reale erinev. Eelmisel juhul olnuks SQL keele omapära tõttu pea võimatu kahest ühesuguse sisuga teatest üht muuta või kustutada, nüüd aga on igal real primaarvõtmeks (alati erinevaks väärtuseks) olev number, mille järgi võib kergesti öelda, millise rea andmeid me küsida või muuta soovime.

<html><body>
 <?php
   require("teatekonf.php");
   mysql_connect($masin, $kasutajanimi, $parool);
   mysql_select_db($baasinimi);
   $korras=mysql_query('
      CREATE TABLE teated1(
         id INT AUTO_INCREMENT, 
         teade TEXT, 
         PRIMARY KEY(id)
      )
   ');
   if($korras){
     echo "Tabel õnnelikult loodud";
   } else {
     echo "Tabeli loomine ebaõnnestus: " . mysql_error();
   }
   mysql_close();
 ?>
</body></html>

Konfiguratsioonifail:
<?php
 $kasutajanimi="juku";
 $parool="kala";
 $masin="localhost";
 $baasinimi="juku1";
?>

Teate lisamiseks on käsklus INSERT INTO. Edasi tuleb tabeli nimi, seejärel veeru või veergude nimed, kuhu andmeid pannakse ning lõpuks väärtused, mis sinna peavad minema. Käsklus mysql_query sobib nii tabelite loomiseks, andmete sisestamiseks kui kustutamiseks. Lihtsalt tuleb sinna sisse sobiv SQL-lause panna. mysql_query väljastab väärtuse, mille järgi saab otsustada, kas käsu täitmine õnnestus. Saamaks viimati tekkinud probleemi kohta teada selle lähemat kirjeldust, on loodud käsk mysql_error.

<html><body>
 <?php
   require("teatekonf.php");
   mysql_connect($masin, $kasutajanimi, $parool);
   mysql_select_db($baasinimi);
   $korras=mysql_query("INSERT INTO teated1 (teade) values('Tervist')");
   
   if($korras){
     echo "Sisestamine õnnestus";
   } else {
     echo "Sisestamine ebaõnnestus: " . mysql_error();
   }
   mysql_close();
 ?>
</body></html>

	Sarnaselt case-käsu näitele võib ka siin kasutaja andmed vormi sisestada ning sealtkaudu teele saata. Andmebaasiga suhtlevate programmide puhul suur osa lehti peabki tegelema kasutajalt andmete pärimise ning talle tulemuste väljastamisega. Teada saamiseks, kas andmeid on saadetud, aitab meid käsk isSet, mis väljastab true või false sõltuvalt sellest, kas vastava nimega muutuja on loodud. 

<html><body>
 <?php
   require("teatekonf.php");
   if(isSet($teatesisu)){
    mysql_connect($masin, $kasutajanimi, $parool);
    mysql_select_db($baasinimi);
    $korras=mysql_query("INSERT INTO teated1 (teade) values('$teatesisu')");   
    if($korras){
     echo "Sisestamine õnnestus";
    } else {
     echo "Sisestamine ebaõnnestus: " . mysql_error();
    }
    mysql_close();
   }
 ?>
 <form>
   <input type="text" name="teatesisu" size="50">
 </form>
</body></html>

Andmete pärimiseks tabelist on SQL-keelde loodud select-lause. Veeru nimeks praegusel juhul teade ning tabeli nimeks teated1. Kord päringu peale saabunud vastustetabelist  saab käsu mysql_fetch_array abil hakata üksikutele ridadele vastavaid väärtusi pärima. Praegusel juhul on meil küll tegemist ühe veeruga, kuid enamasti tuleb uurida rohkem kui ühe veeru andmeid ning siis on täiesti põhjendatud, et peame rea andmeid sisaldavast muutujast  väärtuse küsimisel teada andma, millise veeru andmeid soovime. Kui kõik read läbitud, siis annab käsklus mysql_fetch_array välja tulemuse false, mille peale teatakse väljatrükkimise ja pärimise tsükkel lõpetada. 

<html><body>
 <?php
   require("teatekonf.php");
   if(isSet($teatesisu)){
    mysql_connect($masin, $kasutajanimi, $parool);
    mysql_select_db($baasinimi);
    $vastus=mysql_query("SELECT teade FROM teated1");   
    if($vastus){
      echo "<h2>Teated</h2>\n";
      while($rida=mysql_fetch_array($vastus)){
        echo $rida["teade"]."<br>\n";
      }
    }
    mysql_close();
   }
 ?>
</body></html>

	Kui soovida tabelisse lisada andmeid rohkematesse veergudesse, siis peab nende nimed ja väärtused ka SQL-lausesse kirjutama. Loomulikult peab vastava nime ja veergudega tabel ka andmete sisestamise ajaks loodud olema. 

<html><body>
 <?php
   require("teatekonf.php");
   mysql_connect($masin, $kasutajanimi, $parool);
   mysql_select_db($baasinimi);
   $korras=mysql_query("INSERT INTO teated2 (nimi, teade) ".
      "values('Juku', 'Tervist')");
   if($korras){
     echo "Sisestamine õnnestus";
   } else {
     echo "Sisestamine ebaõnnestus: " . mysql_error();
   }
   mysql_close();
 ?>
</body></html>

	Eelmine näide oli katsetamiseks, sealne kood sisestas tabelisse alati samad väärtused. Üldjuhul ei saa ummisjalu lihtsalt midagi sisse kirjutada, andmed tuleb ikka kasutajalt küsida või millegi põhjal kokku arvutada. Siin pannakse lihtsalt tekstiväljadest võetud andmed sisestatavate väärtuste kohale ning käsu käivitamisel jõuavadki inimese poolt sissetipitud nimi ja teade vastavate väljadena andmebaasi. 
Mitmete veebiliidese koostamise vahendite juures on kasutajalt saadud andmete kuhugile paigutamine suur turvarisk. Kui näiteks SQL-lausesse jõuaks kasutaja ülakoma, siis mõjutaks see lause täitmist, sest lause lahkamisel arvataks, et tegemist on sõneosa lõpuga, edasist loetaks juba järgnevaks käsuks. PHP aga hoolitseb selle eest ning kasutajalt saadav sõne on muutujasse paigutatud nii, et MySQL vastavad andmed ilusti baasi edasi annaks, pannes langjooned vajalikesse kohtadesse varjestamiseks ette. 
Kui veebilehel on andmete sisestamiseks muid komponente peale üksiku tekstivälja, siis peab olema seal ka submit-nupp, et brauser teaks, millal andmed teele saata. Sinna nupule vajutades saadetakse andmed töötlemiseks lehele, mis on määratud form-elemendi algul. Kui lehe aadressi pole määratud, jõuavad andmed samal lehel olevale programmile töötlemiseks, kus vormi elemendidki loodi. 

<html><body>
 <?php
   require("teatekonf.php");
   if(isSet($teatesisu)){
    mysql_connect($masin, $kasutajanimi, $parool);
    mysql_select_db($baasinimi);
    $korras=mysql_query("INSERT INTO teated2 (nimi, teade) ".
      "values('$nimi', '$teatesisu')");   
    if($korras){
     echo "Sisestamine õnnestus";
    } else {
     echo "Sisestamine ebaõnnestus: " . mysql_error();
    }
    mysql_close();
   }
 ?>
 <form>
  <table>
   <tr>
    <td>Nimi:   </td><td><input type="text" name="nimi" size="50"></td>
   </tr><tr>
    <td>Teade:  </td><td><input type="text" name="teatesisu" size="50"></td>
   </tr><tr>
    <td colspan="2" align="center"><input type="submit" value=" Saada "></td>
   </tr>
  </table>
 </form>
</body></html>

	Järgnevas näites on ühitatud lisamise ja pärimise käsud ning tulemuseks on lihtne teadetetahvel. Kui kasutaja on sisestanud teate ja nime, siis lisatakse need kirjena baasi. Samas näidatakse juba olemasolevad nimed ja teated nende sisestamise järjekorras tabelina. Iga päringureaga alustatakse tabelis uut rida ning inimese nimi kirjutatakse rasvases kirjas. 

<html><body>
 <?php
   require("teatekonf.php");
   mysql_connect($masin, $kasutajanimi, $parool);
   mysql_select_db($baasinimi);
   if(isSet($nimi) && isSet($teatesisu)){
     mysql_query("INSERT INTO teated2 (nimi, teade) ".
      "values('$nimi', '$teatesisu')"); 
   }
   $vastus=mysql_query("SELECT nimi, teade FROM teated2");   
   if($vastus){
      echo "<h2>Teated</h2>\n";
      echo "<table>\n";
      while($rida=mysql_fetch_array($vastus)){
        echo "<tr><td><b>".$rida["nimi"]."</b></td>".
             "<td>".$rida["teade"]."</td></tr>\n";
      }
      echo "</table>";
   }
   mysql_close();
 ?>
 <form>
  <table>
   <tr>
    <td>Nimi:   </td><td><input type="text" name="nimi" size="50"></td>
   </tr><tr>
    <td>Teade:  </td><td><input type="text" name="teatesisu" size="50"></td>
   </tr><tr>
    <td colspan="2" align="center"><input type="submit" value=" Saada "></td>
   </tr>
  </table>
 </form>     
</body></html>

Lynx-i nimelise veebibrauseri aknas näeb raamat välja nõnda:

Teated

   Mati Kool hakkab kell 10
   Kati Võta vihikud kaasa
   Mati Matemaatika vihik on kadunud
   Kati Otsi riiuli tagant
   Siim Mina toon palli
   Mati Mina ka
   Kati Jätke mu ilus kleit valgeks

   Nimi:  __________________________________________________
   Teade: __________________________________________________
                            Saada

Valik SQL-i käske koos seletustega

CREATE TABLE teated2(
  id int NOT NULL auto_increment, 
  teade TEXT, 
  nimi TEXT, 
  PRIMARY KEY(id)
);

Luuakse kolme veeruga tabel nimega teated2. Esimese veeru nimi on id, tüübiks int (integer, täisarv). NOT_NULL tähistab, et sellel väljal peab olema väärtus, auto_increment teatab, et iga uue kirje lisamisel suurendatakse selle välja väärtust ühe võrra. PRIMARY KEY hoolitseb, et kõik selle tulba väärtused oleksid erinevad (mis tegelikult juba automaatse nummerdamise tõttu saavutatud on). Primaarvõtit kasutatakse näiteks mitme tabeli puhul nende andmete sidumiseks. 

mysql> explain teated2;
+-------+---------+------+-----+---------+----------------+
| Field | Type    | Null | Key | Default | Extra          |
+-------+---------+------+-----+---------+----------------+
| id    | int(11) |      | PRI | NULL    | auto_increment |
| teade | text    | YES  |     | NULL    |                |
| nimi  | text    | YES  |     | NULL    |                |
+-------+---------+------+-----+---------+----------------+
3 rows in set (0.26 sec)
                                                                  
MySQL-i spetsiifiline käsk tabeli andmete vaatamiseks. Default täistab veeru vaikeväärtus (ehk kui millegagi ei määrata, mida sinna kirjutada tuleks. 

mysql> select * from teated2;
+----+------------------------------+------+
| id | teade                        | nimi |
+----+------------------------------+------+
|  1 | Kool hakkab kell 10          | Mati |
|  2 | Võta vihikud kaasa           | Kati |
|  3 | Matemaatika vihik on kadunud | Mati |
|  4 | Otsi riiuli tagant           | Kati |
|  5 | Mina toon palli              | Siim |
|  6 | Mina ka                      | Mati |
|  7 | Jätke mu ilus kleit valgeks  | Kati |
+----+------------------------------+------+
7 rows in set (0.38 sec)                           

Tahtes näha kõiki tabelis paiknevaid andmeid, võin select-lauses kirjutada veergude nimede kohale tärni. 

mysql> select distinct nimi from teated2;
+------+
| nimi |
+------+
| Mati |
| Kati |
| Siim |
+------+
3 rows in set (0.34 sec)
  
Tahtes näha vaid erinevaid nimesid, võin tulba nime ette kirjutada väärtuse distinct.

mysql> select * from teated2 order by nimi;
+----+------------------------------+------+
| id | teade                        | nimi |
+----+------------------------------+------+
|  2 | Võta vihikud kaasa           | Kati |
|  4 | Otsi riiuli tagant           | Kati |
|  7 | Jätke mu ilus kleit valgeks  | Kati |
|  1 | Kool hakkab kell 10          | Mati |
|  3 | Matemaatika vihik on kadunud | Mati |
|  6 | Mina ka                      | Mati |
|  5 | Mina toon palli              | Siim |
+----+------------------------------+------+
7 rows in set (0.07 sec)                  

Piirang order by käsib väljastatavad andmed sorteerida veeru “nimi” järgi. 

mysql> select * from teated2 order by nimi desc;
+----+------------------------------+------+
| id | teade                        | nimi |
+----+------------------------------+------+
|  5 | Mina toon palli              | Siim |
|  1 | Kool hakkab kell 10          | Mati |
|  3 | Matemaatika vihik on kadunud | Mati |
|  6 | Mina ka                      | Mati |
|  2 | Võta vihikud kaasa           | Kati |
|  4 | Otsi riiuli tagant           | Kati |
|  7 | Jätke mu ilus kleit valgeks  | Kati |
+----+------------------------------+------+
7 rows in set (0.03 sec)
                                              
Kui order by juurde on kirjutatud desc, siis tuleb sorteerida vastupidises järjekorras. 

mysql> select * from teated2 limit 4;
+----+------------------------------+------+
| id | teade                        | nimi |
+----+------------------------------+------+
|  1 | Kool hakkab kell 10          | Mati |
|  2 | Võta vihikud kaasa           | Kati |
|  3 | Matemaatika vihik on kadunud | Mati |
|  4 | Otsi riiuli tagant           | Kati |
+----+------------------------------+------+
4 rows in set (0.14 sec)

Suurte andmehulkade puhul ei soovi me neid mõnikord kõiki korraga näha. Käsk limit ütleb, mitut esimest päringule vastavat kirjet näidatakse.

mysql> select * from teated2 limit 3, 2;
+----+--------------------+------+
| id | teade              | nimi |
+----+--------------------+------+
|  4 | Otsi riiuli tagant | Kati |
|  5 | Mina toon palli    | Siim |
+----+--------------------+------+
2 rows in set (0.00 sec)

Kui soovida näha andmeid suure hulga keskelt, siis tuleb limit’ile teada anda, mitmendast reast ja kui palju soovime näha. Sarnaselt käitutakse näiteks otsimootorites, kus esialgu väljastatakse paarkümmend vastavust ning edasi vastavalt kasutaja soovile jupikaupa juurde. 

mysql> select * from teated2 where nimi='Kati';
+----+-----------------------------+------+
| id | teade                       | nimi |
+----+-----------------------------+------+
|  2 | Võta vihikud kaasa          | Kati |
|  4 | Otsi riiuli tagant          | Kati |
|  7 | Jätke mu ilus kleit valgeks | Kati |
+----+-----------------------------+------+
3 rows in set (0.00 sec)
                            
Tahtes näha vaid Kati saadetud teateid, tuleb select-lausele juurde lisada where osa, kus näidatakse vaid kirjeid, mis vastavad seal seatud tingimus(t)ele. 

mysql> select count(*) as nr from teated2 where nimi='Kati';
+----+
| nr |
+----+
|  3 |
+----+
1 row in set (0.32 sec)

Tingimusele vastavaid kirjeid saab kokku lugeda käsuga count. Sõnad “as nr”  selle taga tähendavad, et avaldise count väärtus esitatakse tulbas nimega nr ning seda on võimalik koodis küsida nagu iga muu tavalise tulba väärtust. 

                                                          
mysql> select nimi, count(*) as kogus from teated2 group by nimi;
+------+-------+
| nimi | kogus |
+------+-------+
| Kati |     3 |
| Mati |     3 |
| Siim |     1 |
+------+-------+,
3 rows in set (0.01 sec)

Tahtes üle lugeda, mitu teadet iga isik saatnud on, tuleb vastused nime järgi grupeerida. 

mysql> select nimi, count(*) as kogus from teated2
   group by nimi having kogus>1;

+------+-------+
| nimi | kogus |
+------+-------+
| Kati |     3 |
| Mati |     3 |
+------+-------+
2 rows in set (0.01 sec)

Piirang having võimaldab gruppide hulgast näidata vaid soovituid. 

Kokkuvõte

Siinsel paariteistkümnel lehel vaadatud vahendeid pruukides ja kombineerides õnnestub koostada lihtsamaid PHP-lehekülgi, talletada kasutajalt küsitud andmeid ning vastata päringutele. Mõttetöö tulemusena võib luua nii registreerimisvormi kui elektroonilise sõiduplaani. Keerukamate andmete puhul tuleb aga luua mitu andmetabelit ja neid omavahel ühendada. See aga on juba järgmine teema.