Programozás | PHP » A PHP nyelvről kezdőknek

A PHP nyelv A PHP egy szerver oldali script nyelv. A ColdFusion-hoz, vagy az ISAPI-hoz hasonlóan, a válasz lap formátumát leíró utasítások egy HTML dokumentumba ágyazva helyezkednek el. A minta dokumentum azon utasításai, melyek normál HTML utasítások, változtatás nélkül átkerülnek a válasz lapra. A speciális, a PHP specifikus elemeket a PHP végrehajtja, s a generált válasz kerül be az eredmény lapra. Ugyan a PHP leíró nyelve nem adatbázis orientált, hanem a C általános programozási nyelvre épül, mégis tartalmaz egy sor adatbázis kapcsolódási kiegészítő modult, amely lehetővé teszi hogy elérhessük, s a válasz lapon megjeleníthessük a legkülönbözőbb adatbázisokban tárolt adatokat is. Az adatbázis kapcsolódási felületek között szerepel az ODBC kapcsolat is. A WEB szerver itt is a meghívott dokumentum URL –jéből ismeri fel, hogy a kérést a PHP szervernek kell feldolgoznia. A PHP rendszer működési struktúrája az

említett rendszerekhez hasonlóan az alábbi elemekből épül fel: - Browser WEB szerver PHP szerver Minta dokumentum WEB szerver URL PHP szerver Adatbázis szerver Séma dokumentum A fenti struktúra alapján a PHP kérések feldolgozása az alábbi lépésekben fut le: 1. az olvasott lapon kiadnak egy hiperlink kapcsolódást egy olyan URL-re, mely mögött PHP hívás rejlik. Egy ilyen cím lehet például a következő: http://kov.iituni-miskolchu/php/aphp illetve a hivatkozást más esetekben a http://kov.iituni-miskolchu/aphp formában is megadhatjuk. Ezen hivatkozásokban az URL első része jelöli ki, hogy mely gépen található a WEB szerver és a PHP szerver. Az első mintában a /php/ rész egy virtuális könyvtár, mely jelzi a WEB szervernek, hogy itt egy PHP dokumentumot kell kezelni, s meg kell majd hívni a PHP szervert. A virtuális útvonal kijelölésének menete WEB szerver specifikus, rendszerint a WEB szerver konfigurációs állományát kell

módosítani a virtuális útvonal kijelöléshez. Az Apache szerver esetén például az alábbi jellegű beállításokat kell elvégezni: ScriptAlias /php/ "c:/path-to-php-dir/" A második mintában a nem kellett virtuális könyvtár ahhoz, hogy a WEB szerver tudja, hogy a PHP szervert kel meghivnia. Ebben az esetben ugyanis a dokumentum kiterjesztése utal arra, hogy a dokunetumot a PHP fogja kezelni. A kiterjesztések és a kezelő programok összerendelése is a Web szerver konfigurációs állományában történik. Egy ilyen beállítást mutat az alábbi Apache példa: AddType application/x-httpd-php .php AddType application/x-httpd-php .phtml Action application/x-httpd-php "/php/php.exe" Az URL utolsó tagja, példánkban a a.php rész a séma dokumentumot jelöli ki, mely megadja a válasz lap előállításának módját. 2. A WEB szerver érzékeli, hogy a meghívott URL a PHP szerverhez kapcsolódik, ezért meghívja a PHP modult végrehajtásra.

A PHP szerver kétféle módban is működhet, lehet CGI és lehet API módban is. 3. A PHP modul megkapja a végrehajtási feladatot a feldolgozandó séma dokumentum azonosítójával együtt. A PHP szerver átolvassa, s elemzi a séma dokumentumot. A PHP specifikus utasításokat értelmezi, s végrehajtja a PHP szerver. 4. Ha adatbázis hozzáférési igények is felmerültek a PHP specifikus utasítások között, akkor a PHP szerver kapcsolatba lép az adatbázis kezelővel, s végrehajtja a kijelölt műveletsort. A PHP specifikus utasítások között megtalálhatok azon elemek is melyekkel leírható, hogyan jelenjenek meg az eredmény adatok a válaszdokumentumban. 5. A generált válaszlap a normál HTML utasítások és a dinamikus elemekből felépülve, átkerül a WEB szerverre, majd onnan eljut az őt igénylő böngészőhöz is. A PHP szerver is egy többrétegű, több komponensből álló rendszer. A rendszer elvi felépítési vázát mutatja be a következő

ábra: WEB Szerver PHP szerver SAPI PHP Core Zend Core Extension API Extension (pl. MySQL) Séma leirás Az SAPI (Szerver Absztrakciós Réteg) a különböző WEB szerverekhez történő kapcsolódást oldja meg, egy egységes felületet képezve a felette elhelyezkedő rétegek számára. Jelenleg támogatott felületek: Apache, Roxen, Java (servlet), ISAPI, AOLserver és CGI. A Zend Core modul nyelvi parser szerepet tölt be a rendszerben. Az egyes kiterjesztések teszik lehetővé az különböző adatbázis források elérését. A PHP rendszer első verziója 1994 kürül jelent meg. Az első verzió kidolgozása Rasmus Lerdorf nevéhez fűződik. Az 1995-ös évben jelent meg egy javított, a FORM elemeket is kezelő PHP2 verzió. Ekkor a PHP még csak az Apache WEB szerverrel tudott együttműködni. A PHP3-as változat már kereskedelmi termékké is kinőtte magát, s piaci vagy ingyenes változatának is több százezer felhasználója lett világszerte. A 2000-es

évben már a PHP4 verzió is megjelent, melybe épült be először a Zend optimalizált értelmező és kibővített WEB szerver kapcsolatrendszer. A széles adatbázis támogatást mutatja, hogy a PHP4 verziója már a következő adatforrásokat támogatja: Adabas D Dbase Empress FilePro (read-only) IBM DB2 Informix Ingres InterBase FrontBase mSQL Direct MS-SQL MySQL ODBC Oracle (OCI7 and OCI8) PostgreSQL Solid Sybase Velocis Unix dbm A PHP rendszer nyelvi elemei A PHP specifikus utasítások a HTML utasítások közé beillesztve, beágyazva foglalnak helyet. A normál HTML utasításoktól való egyértelmű és könnyen kezelhető szétválasztás érdekében az egyes PHP specifikus utasításokat keretbe foglaljuk, s elkülönítjük a normál HTML elemektől. Az elhatárolás az alábbi változatok valamelyikével lehetséges <? PHP elemek ?> <?php PHP elemek ?> <script language=”php”> PHP elemek </script> <% PHP elemek %> A fenti

változatok közül a második amelyik tömör és mégis utal arra, hogy a közrefogott utasítások a PHP szervernek fognak szólni. A PHP elemek, mint említettük C nyelvi kifejezésekhez hasonló formátumot öltenek. Egy tagolt rész több elemi PHP kifejezést, utasítást is tartalmazhat. Ekkor az egyes PHP utasításokat pontosvesszővel határoljuk el egymástól: <?php PHP utasitas1; PHP utasitas2; %> A fenti példából is látható, hogy a tagolási rész, s maga az egyes PHP elemi utasítás is több forrássoron keresztül is folytatódhat, s sorvégjel nem jelent utasítás határt. Ha szövegszerkesztővel létrehozunk egy elso.php állományt, melynek tartalma a következő: <?php echo “Hello vilag”; ?> akkor e PHP séma dokumentum már értelmezhető és végrehajtható a PHP szerverrel. Ehhez át kell adni egy URL kérést a WEB szervernek a fenti dokumentumot megjelölve: Ha a PHP utasítások közé megjegyzést szeretnénk beilleszteni,

akkor erre is többféle szintaktikai lehetőségünk van: - /* szoveg / : ekkor több sorra is kiterjedhet a megjegyzés rész, a közrefogott szöveg nem kerül értelmezésre a PHP szerver által. - // szoveg : ekkor a megjegyzés kezdetétől az aktuális sor végéig terjedő rész lesz a megjegyzés rész - # szoveg : ugyanolyan értelmezésű, mint az előző formátum, azaz ekkor a megjegyzés kezdetétől az aktuális sor végéig terjedő rész lesz a megjegyzés rész A PHP séma kifejezések saját memória változókat is tartalmazhatnak. A memória változókat PHP értékadó utasításokkal hozhatjuk létre. A változók kezelésénél az alábbi alap információkra lehet szükségünk: - a változók azonosítója mindig a $ jellel kezdődik: $a - az értékadás legyen az első hivatkozás a változóra $a = 34.5 - a felvett érték szabja meg a változó típusát A PHP rendszer az alábbi alaptípusokat támogatja: - egész pld, $a = -455; valós, pld. $b = 9856;

szöveges pld $c = ”alma”; A szöveges változók lehetnek egy s lehetnek több karakter hosszúak. A szöveges kifejezéseknél két szöveges kifejezés összefűzhető a . operátorral: $b = “fa”; $c = “alma” . $b ; esetében a c változó az “almafa” értéket fogja tárolni. A változók a skalár érték mellett tömb típusúak is lehetnek. A tömb kezelés egyedi vonása, hogy - tömb létrehozása az elemeinek a megadásával történik, nem előzetes helyfoglalással a tömbelemek indexe az egész típusú értékek mellett lehet asszociatív, mikor egy szöveges kifejezés adja meg az index értékeket $b[1] = 3; $b[2] = ”alma”; $b[”peter”] = 34; Több dimenziós tömbök esetében a C szintaktikát követve minden dimenziónál külön szögletes zárójelben adjuk meg az indexértékét: $a[3][2] = 23; A változókat, mint a példákból is láthattuk, nem kell előre definiálni, s típusukat ezért az értékadás határozza meg. Egyazon

változóhoz egymásután más és más típusú kifejezés is rendelhető, ezért annak típusa a program futása során dinamikusan, menetközben megváltozhat. A PHP kódrészlet tartalmazhat függvény definíciót is. A függvényt a function kulcsszóval kell bevezetni. A függvény paramétereket kaphat indításakor, melyek alapján határozza meg a visszatérési értékét. A függvény definiálását és meghívását mutatja be a következő példa: <?php function novel ($p) { return $p + 1; } $v = novel(3); ?> A példában a $v változó a 4 értéket fogja felvenni. A PHP egy objektum orientált környezetet valósít meg, így többek között lehetőséget ad osztályok és objektumok használatára is. Egy osztályt definálni a class kulcsszóval lehetséges, melynek során megadjuk az osztály tulajdonságait a var kulcsszón keresztül, s definiáljuk a metódusait is a function kulcsszó segítségével. Az osztályok között öröklési mechanizmus is

definiálható. A következő példa egy ilyen esetet mutat be, melyben a most létrehozott osztály a kutya, s az ős osztály az allat: class kutya extends allat { var gazdi; var oltva; function beolt() { . } . } A példában a gazdi és az oltva tulajdonsága lesz az osztálynak, míg a beolt egy metódusa. Az osztályhoz objektum a new operátorral hozható létre. $bodri = new kutya; Az objektum változói és metódusai az objektum->azonosító formalizmussal érhető el: bodri->gazdi = ”anna”; bodri->beolt(); A saját változók mellett a rendszer egy sor úgynevezett rendszerváltozót is elér, melyek a futató környezetről adnak valamilyen információt. Néhány fontosabb rendszerváltozót ad meg a következő felsorolás: - SERVER NAME: a szerver gép azonosítása REMOTE ADDR: az igénylő, böngésző gép azonosítása HTTP COOKIE VARS: a klienstől kapott cookie változók listája A PHP részben létrehozott változók a létrehozás helyétől

függően lehetnek globálisak vagy lokálisak. A globális változók a séma dokumentumban a létrehozás helyétől a dokumentum végéig láthatók. A létrehozási hely előtt viszont nem láthatók, hiszen ekkor még nem is léteznek. A lokális változók a függvényekben definiált változók, melyek alapesetben csak a függvényen belül láthatók. A lokális változók elrejtik az ugyanilyen néven létrehozott globális változókat. Ha a függvényen belül is a már létrehozott globális változókat szeretnénk elérni, akkor a függvényben a változók definiálásakor a global kulcsszót kell megadni: function masik() { global $x ; $v = $x + 1; } A kifejezések képzésekor a konstans és változó értékekből operátokkal újabb értékeket képezhetünk. A PHP kifejezésekben a C nyelvben megszokott operátorok alkalmazhatók: + * / % = +=,-=,*=,. & | ^ ~ >> << == != < > <= >= Összeadás Kivonás Szorzás Osztás Maradék

Értékadás Növelés, csökkentés, Bitenkénti és Bitenkénti vagy Bitenkénti kizáró vagy Bitenkénti negáció Bitenkénti shift jobbra Bitenkénti shift balra Egyezőség Nem egyezőség Kisebb Nagyobb Kisebb vagy egyenlő Nagyobb vagy egyenlő `` ++ -And Or Xor ! && || Végrehajtás Növelés eggyel Csökkentés eggyel Logikai és Logikai vagy Logikai kizáró vagy Logikai tagadás Logikai és Logikai vagy A fenti operátorok közül talán egy, a végrehajtás operátora, ami nem jelent meg a C nyelvben ilyen formában. Ha a PHP ilyen felsővesszők közé zárt sztringet talál a kifejezésben, akkor megpróbálja annak tartalmát shell parancsként lefuttatni. A végrehajtás eredménye fog ezután a parancs sztring helyébe kerülni az eredményben. A következő példa azt mutatja, amikor egy directory listát teszünk ki az eredmény lapra: <?php echo "<pre>".`dir`"</pre>" ; ?> Az egyes operátorok közötti

kiértékelési sorrendet az operátorok precedenciája határozza meg, mely a C-ben megszokott sorrendet tartalmazza a PHP-nál is. társitási irány Bal Bal Bal Bal Jobb Bal Bal Bal Bal Bal Bal Left Bal Bal Bal Jobb Jobb - művelet , or xor and print = += -= *= /= .= %= &= |= ^= ~= <<= >>= ?: || && | ^ & == != === !== < <= > >= << >> +-. */% ! ~ ++ -- (int) (double) (string) (array) (object) @ [ new A kifejezések mellett a PHP nyelv vezérlési szerkezetetek is tartalmaz, melyek szintén a C nyelvbeli szintaktikához hasonlítanak. Feltételes végrehajtás: a jól ismert if kulcsszóval adható meg: if ($a > $b) { print "a nagyobb mint b"; } else { print "a nem nagyobb mint b"; } A többszörös elágazáshoz a swicth kifejezés használható: switch ($i) { case 0: print "i equals 0"; break; case 1: print "i equals 1"; break; case 2: print "i equals 2"; break; } Elől

tesztelős ciklus : itt a while kifejezés használható: $i = 1; while ($i <= 10) { print $i; $i++; } Hátul tesztelős ciklus: a do . while kifejezés: $i = 0; do { print $i; } while ($i>0); A léptetéses ciklus, a for ciklus is használható: for ($i = 1; $i <= 10; $i++) { print $i; } Ciklus egy tömb minden egyes elemére: a foreach ciklus használható: foreach ($arr as $value) { echo "Value: $value<br> "; } Ebben a kifejezésben az $arr volt a tömb azonosító, s $value az a változó, amely sorban felveszi a tömb egymásutáni elemeit a ciklus végrehajtása során. A ciklusokból, a ciklus magból menetközben is ki lehet lépni a break; utasítás segítségével, s át lehet ugorni a ciklusmag hátralévő részét a continue; utasítással. Egy külső forrás állomány betöltése végrehajtásra az include(állomány); utasítással lehetséges. A behívott az állományban szintén szerepelhetnek PHP utasítások, melyeket ott is

érvényes keret szimbólumok közé kell elhelyezni. !!!egnezni hogyan lehet jelszot keretni es azt felhasznalni A PHP rendszer lehetőséget ad arra is, hogy a böngésző oldali változókat, úgynevezett cookie elemeket is definiáljunk. Ehhez a válasz lapon ki kell adni egy setcookie függvényhívást, amellyel megadható a cookie elem azonosítója, s értéke is. Az így beállított változó a legközelebbi híváskor már látható lesz. A cookie elem törlésére is a setcookie függvényt kell meghívni. A következő példa egy egyszerű cookie definíciót mutat be: <?php setcookie(“teszt”,”alma”); echo “$teszt”; ?> A példában egy teszt elnevezésű cookie elem jött létre, mely az alma szövegértéket fogja felvenni. A php dokumentum első meghívásakor az echo parancs még üres sztringet ír ki, s csak a második meghívás alkalmával fog az alma szöveg megjelenni a válasz dokumentumban. A cookie elem törléséhez a setcookie függvényben

ki kell hagyni az érték argumentumot. Állományok kezelése a szerveren A PHP dokumentumok alkalmasak arra, hogy a kliens oldalról átvegyünk állományokat a szerver oldalra. Az áttöltés két lépcsőben zajlik le Egyrészt szükség van egy olyan űrlapra, mely elindítja az állomány áttöltését, ami az állományt a szerver oldalon egy ideiglenes tároló helyre leteszi. Második lépcsőben az ideiglenes tároló helyről, ahonnan automatikusan törlődik az állomány, át kell vinni azt a végleges célhelyre. Eközben egy ellenőrzést is végre lehet hajtani, hogy megfelel-e a felküldött állomány típus, méret szempontjából, mert ha nem akkor nem kerül végleges lehelyezésre. Az áttöltés lépésit, elemeit szemlélteti a következő példa: Az átvitelt kiváltó lap tartalma: <FORM ENCTYPE="multipart/form-data" ACTION="/e.php" METHOD=POST> <INPUT TYPE="hidden" name="MAX FILE SIZE"

value="10000"> Atküldött állomány: <INPUT NAME="sfile" TYPE="file"> <INPUT TYPE="submit" VALUE="Send File"> </FORM> A fogadó PHP dokumentum tartalma: <?php echo “ideiglenes helye $sfile”; echo “eredeti nev : $sfile name”; echo “meret : $sfile size”; echo “tipus : $sfile type”; if (!copy ($sfile,”minta.txt”) ) { echo “hiba”; } ?> A PHP kódban a hivatkozott változó azonosítója megegyezik a feltöltő űrlapban megadott mezőazonosítóval, ami esetünkben az sfile azonosító volt. A program az ideiglenes helyre letett állományt egy fix állományba viszi át, másolja át a copy függvény segítségével. A sikertelen átmásolás esetén hiba üzenetet kap vissza a felhasználó. Az állományok feltöltése mellett lehetőség van a szerver oldalon elhelyezett állományok közvetlen, rekord szintű kezelésére is. A PHP is használhatjuk ugyanis a C-ben megismert

állománykezelő mechanizmust, vagyis építhetünk többek között az alábbi függvényekre: chgrp állomány csoport módosítás chmod állomány elérési mód módosítás chown állomány tulajdonos módosítás copy állomány másolás diskfreespace szabad hely mérete fclose állomány lezárás feof állományvég lekérdezés fgetc karakter beolvasás fgets sor beolvasás file teljes állomány beolvasása tömbbe file exists állomány létezés ellenőrzése fileatime állomány módosítás dátuma fileowner állomány tulajdonos lekérdezés fileperms állomány elérési mód lekérdezés filesize állomány méret lekérdezés filetype állomány típus lekérdezés fopen állomány megnyitás fputs írás állományba fread állomány olvasás binárisan fscanf állomány olvasás formátmozottan fseek pozicionálás az állományban ftell állomány pointer pozíciója ftruncate állomány csonkítás fwrite állomány írása

binárisan is dir megadja, hogy a név mögött állomány vagy katalógus van-e is writeable megadja, hogy az állomány írható-e mkdir katalógus létrehozás rename állomány átnevezés rewind állomány pointer visszaállítás az állomány elejére rmdir katalógus megszüntetés stat információ kérés az állományról tmpfile ideiglenes állomány létrehozatala unlink állomány törlése Az alábbi példában az alapértelmezési dokumentum könyvtárba letett minta.txt állomány tartalmát jelenítjük meg a válasz dokumentumban: <?php $file = fopen ("minta.txt", "r"); if (!$file) { echo "<p> nyitasi hiba. "; exit; } while (!feof ($file)) { $line = fgets ($file, 1024); echo "$line <br>"; } fclose($file); ?> A minta programban az fopen nyitja meg az állományt. A sikerességet itt is a függvény visszatérési értékén keresztül vizsgáljuk. Az állomány tartalmát soronként előbb

behozzuk a $line változóba, majd annak tartalmát kitesszük a válasz dokumentumba is. Az ODBC adatkapcsolat A PHP szerver lehetővé teszi, hogy a PHP kódszeleten belül ne csak a saját vagy a környezeti változókat érjük el, hanem más adatbátzis adatforrásokból is nyerhessünk ki adatokat. A több különböző lehetséges adatforrás tipus közül mi most az ODBC forrást fogjuk áttekinteni. E adattipus előnye, hogy egyrészt ezen keresztül számos más adtforrás is elérhető lesz, másrészt a PHP szerver z ODBC kapcsolatot alapértelemezés szerint magában foglalja, igy nincs szükség külön modul beépitésére az installáció során. Az adatkapcsolat jellege, menete hasonlit a már megismert CLI felületekhez, hisz itt is lényegében egy C nyelvű gazdanyelvi környezetbe kell beépiteni az adatkezelést megvalósitó utasitásokat. Az adatkezelés lépési itt is a szokott fő elemeket tartalmazzák, azat itt is meg kell oldani a következő feladatokat:

- adatforrás azonositása, kapcsolat felvétele parancsok elküldése eredmények fogadása hibakezelés, tranzakció és információ kezelés A séma lap feldolgozásakor tehát első lépésben majd kapcsolódni kell a kijelölt adatforráshoz. Ez a lépés viszonylag időigényes, hiszen azonositani kell a klienst és sikeres ellenőrzés esetén allokálni kell a DBMS erőforrásokat az őt kiszolgáló szerver processzhez. Másrészt látható az is, hogy gyakran meg kell ismételni, hiszen minden adatbázis kezelést végző séma lap feldolgozásnál el kell végezni ezt a lépést. A PHP egyik új lehetősége, hogy az úgynevezett perzisztens adatbázis kapcsolat mechanizmusával csökkenti az adatbázis kapcsolódási időigényt. Ezen mechanizmus lényege, hogy a PHP szerver nem bontja le rögtön a létrejött adatbázis kapcsolódásokat, hanem mehagyja a lehetőséget arra, hogy azt később újra felhasználhassa. Természetesen csak akkor tud egy kapcsolatot újra

felhasználni, ha az pontosan ugyanarra az adatforrásra, ugyanazon felhasználói névhez kötődik. A perziszetens adatkapcsolat nem használható abban az aesetben, ha a PHP szerver CGI módban dolgozik. A következőkben áttekintjük a ODBC források kezeléséhez felhasználható függvényeket: Adatkapcsolat felvétele: Normál adatkapcsolat felvétele az odbc connect függvénnyel történik. Szintakikája: int odbc connect(string dsn, string user, string password, int [cursor type]); A paraméterek közül az első az ODBC adatforrás azonositó DSN értékét jelenti, a második a felhasználó azonositó neve és a harmadik a jelszava. A negyedik opcionális paraméter az igényelt cursor tipust határozza meg. A SQL CUR USE ODBC beállitás esetén várható a legkisebb konfliktus veszély az adatbáziskezelővel. A sikeres kapcsolat felvétel esetén nem zésus értékkel tér viszza az odbc connect föggvény, mig a zérus érték hibát jelez. A nemzésus

visszatérési érték esetén a visszadot azonositót egy kapcsolat azonositó változóba helyezzük le. Ez a változó fogja a továbbiakban kijelölni, hogy melyik kapcsolatra is voantkozik az adatkezelő utasitás. Ugyanis itt is több kapcsolat élhet párhuzamosan Perzisztens adatkapcsolat felvétele a odbc pconnect függvénnyel történik. Szintakikája: int odbc pconnect(string dsn, string user, string password, int [cursor type]); A függvény paraméterezése és hibakezelése ugyanolyan mint a odbc connect függvény esetében. Adatkapcsolat megszakitása az odbc close függvénnyel történik. Szintakikája: void odbc close(int connection id); ahol a függvény paramétere a lezárandó kapcsolatot kijelölő változó. Az összes ODBC kapcsolat lezárása az odbc close all függvénnyel történik Szintaktikája: void odbc close all(void); E függvény nem is igényel bemenő paramétert. Adatkezelő parancsok kiadása Egy SQL parancs átküldése az ODBC forráshoz

végrehajtásra az odbc exec függvénnyel történik Szintaktikája: int odbc exec(int connection id, string query string); A függvény első paramétere a kapcsolat azonositó, mig a második a végrehajtandó SQL utasitás. Ennél az alaknál a DBMS a kapott sztringet előbb értelmezi, optimalizálja majd végrehajtja. Ebben az esetben minden parancs egy teljesen új parancsként kerül végrehajtásra Ha egyazon parancsot többször meg fogunk ismételni, akkor e módszer erőforrás pazarlóan dolgozik, hiszen egyes előkészitő lépéseket feleslegesen ismétel meg. Ekkor inkább a következőkben felvázolt megoldás ajánlható. Az odbc exec parancs hiba esetén a hamis, 0 értéket adja vissza. Hibátlan lefutás esetén egy eredmény azonositó lesz a föggvénz visszatérési értéke. Egy SQL parancs átküldése az ODBC forráshoz előfeldolgozásra az odbc prepare függvénnyel történik Szintaktikája: int odbc prepare(int connection id, string query string);

Paraméterezése megegyezik a odbc exec utasitás paraméterzésével. Ebben az esetben viszont az utasitás nem fog lefutni, azt egy későbbi időpontban, esetleg többször is megismételve lehet majd elvégezni. Hogy melyik előkészitett parancsot kell elvégezni, azt a visszadatott eredmény azonositóval tudjuk kijelölni. Hiba esetén hamis éréket ad vissza az odbc prepare függvény. Előkészitett SQL parancs végrehajtása az ODBC forrásban az odbc execute függvénnyel történik Szintaktikája: int odbc execute(int result id, array [parameters array]); A fenti függvényben az első paraméter a prepare függvényben visszadott eredmény azonositót jelöli. A második paraméter egy opcionális tömb, amely elemeivel fog a konkrét SQL utasitás lefutni. Mint ebből már látható, a kétfázisú végrehajtás igazából az által lesz előnyös, hogy nem szükséges, hogy a megismételt parancsok krakterről karakterre, értékről értékre mindig ugyanaz legyen.

Elegendő ugyanis, ha csak a parancs, a kulcsszavak egyeznek meg A felhasznált paraméterek értékei eltérhetnek egymástól. Vagyis egy SELECT rsz FROM auto WHERE ar < 100; és egy SELECT rsz FROM auto WHERE ar < 200; utasitás, mivel csak a paraméterben térnek el egymástól, a parancs struktúrája ugyanaz, nevezetesen SELECT rsz FROM auto WHERE ar < X; alakú, ezért a fenti általános alakot használhatjuk a parancsok előkészitésére. A konrkét futtatásnál az X szimbólum helyébe előbb a 100,majd a 200 érték fog helyettesitődni. A függvény visszatérési értéke egy sikeresség jelző. Eredmény adatok fogadása A lekérdezés eredményei itt is egy cursor struktúrán keresztül érhetők el. A cursor adatinak kezelésére azonban többlehetséges módszer is kiálkozik. A cursor megadott rekordjának áttöltése a program memóriába az odbc fetch row függvénnyel történik Szintaktikája: int odbc fetch row(int result id, int [row number]); Az

első paraméter az eredmény azonositó. A második paraméter a lekért rekord sorszáma Ha ezt nem adjuk meg akkor a soronkövetkező rekord kerül beolvasásra. A visszatérési érték egy sikeresség jelző, mely logikai értékű. Az áthozott adatokat a result függvénnyel lehet majd elérni. A cursorból behozott rekord meőértékeinek lekérdezése az odbc result függvénnyel történik Szintaktikája: string odbc result(int result id, mixed field); Az első paraméter az eredmény azonositó. A második paraméter a mező kijelölésére szolgál Értéke lehet egy szám, jelezve a mező sorszámát és lehet egy azonositó név, megadva a lekért mező nevét. A függvény visszatérési értéke a lekért mező aktuális értéke Ha a teljes eredmény táblát szeretnénk megjeleniteni egy táblázatban, akkor legcélszreűbb az odbc result all függvényt meghivni, melynek szintaktikája: int odbc result all(int result id, string [format]); Ez a függvény a teljes

eredménytáblához generál egy HTML táblázatot az eredmény adatokat megjelenitve. A függvény második paramétere egy opcionális táblázat formátum specikáció A cursor megadott rekordjának tartalmát az odbc fetch into függvénnyel tudjuk átteni egy tömbbe. Szintaktikája: int odbc fetch into(int result id, int [rownumber], array result array); A függvény első paramétere az eredmény azonositó, a második a kijelölt rekord sorszáma, a harmadik pedig azon tömbb neve, amelybe átkerülnek az eredményrekord mezőértékei. Ha nem adunk meg rekord poziciót, akkor a soronkövetkező rekord kerül beolvasásra. Az eredmény halmazban tartalmazott rekordok darabszámát az odbc num rows függvénnyel tudjuk lekérdezni. Szintaktikája: int odbc num rows(int result id); A függvény paramétere az érintett eredmény atonositót tartalmazza. Ha a művelet SELECT volt, akkor a visszatérési érték az eredménytábla rekordjainak a darabszáma. Ha a művelet DML

utasitás volt, akkor a vissztérési érték az érintett rekordok darabszáma lesz. Hiba esetén –1 lesz a visszaadott érték. Az eredmény halmazban tartalmazott mezők darabszámát az odbc num fields függvénnyel tudjuk lekérdezni. Szintaktikája: int odbc num fields(int result id); A függvény paramétere az érintett eredmény atonositót tartalmazza. A visszatérési érték az eredménytábla mezőinek a darabszáma. Hiba esetén –1 lesz a visszaadott érték Az eredmény halmazban tartalmazott mezők azonositó nevét az odbc field name függvénnyel tudjuk lekérdezni. Szintaktikája: string odbc field name(int result id, int field number); A függvény első paramétere az érintett eredmény azonositót tartalmazza, a második parméter a keresett mező sorszáma. A visszatérési érték a mező azonositó neve Hiba esetén logikai hamis lesz a visszaadott érték. Az eredmény halmazban tartalmazott mezők tipusát az odbc field type függvénnyel tudjuk

lekérdezni. Szintaktikája: string odbc field type(int result id, int field number); A függvény első paramétere az érintett eredmény azonositót tartalmazza, a második parméter a keresett mező sorszáma. A visszatérési érték a mező tipusa Hiba esetén logikai hamis lesz a visszaadott érték. Az eredmény halmazban tartalmazott mezők hosszát az odbc field len függvénnyel tudjuk lekérdezni. Szintaktikája: string odbc field len(int result id, int field number); A függvény első paramétere az érintett eredmény azonositót tartalmazza, a második parméter a keresett mező sorszáma. A visszatérési érték a mező hossza Hiba esetén logikai hamis lesz a visszaadott érték. Hamár nincs szükség az eredmény halmazra, akkor azt az odbc free result függvénnyel lehet felszabaditani. Szintaktikája: int odbc free result(int result id); ahol a paraméter az eredmény sruktúra azonositó értéke. Tranzakció kezelés Tranzakció végelegesitése az odbc

commit függvénnyel történik, alakja: int odbc commit(int connection id); melyben a paraméter a kapcsolat azonositása. Sikertelség esetén logikai hamis lesz a visszatérési érték. Tranzakció visszagörgetése az odbc rollback függvénnyel történik, alakja: int odbc rollback(int connection id); melyben a paraméter a kapcsolat azonositása. A tranzakció kezelés jellegét lehet beállitani az odbc autocommit fügvvénnye, szintaktikája: int odbc autocommit(int connection id, int [OnOff]); Az első paraméter a kapcsolat azonositó. A második megadja, hogy autocommit üzemmódban dolgozzon-e a rendszer vagy sem. Az autcommit esetén minden végrehajtott parancs után a DBMS rögtön véglegesit. Kikapcsolva az autocommit módot, a tranzakciók a commit utasitásig fognak tartani. Ha nem szerepeltetjük a második paramétert, akkor a függvény nem beállitja, hanem lekérdezi az autocommit mód aktuális állapotát. A műveletvégrehajtás többi paraméterének

beállitására szolgál az odbc setoption függvény, melynek alakja: int odbc setoption(int id, int function, int option, int param); Az első paraméter a kapcsolat azonositó, a második a paraméter jellege. Ha a paraméter a kapcsolatra vonatkozik, akkor 1-et kell itt megadni, ha a parancsra akkor 2-t kell beállitni. A harmadik argumentum az ODBC paramétert azonositja, azaz azt adja meg hogy mit is kell müdositani. A negyedik argumentum az ODBC paraméter új értékét adja meg Mintapéldák Példa 1. Az első példában egy adatbázisban tárolt tábla tartalmát jelenítjük meg a válaszlapon. A lekérdezéskor a teljes táblát visszaadjuk. A tábla azonosító neve PAUTO és az őt tartalmazó adatbázis ODBC DSN azonosítója ORAPROPA. A séma PHP állomány, a MINTA1.PHP ekkor a következő tartalmú: <?php $conn = odbc connect("ORAPROBA","scott","tiger"); if (! $conn) { echo "Hibas ODBC kapcsolat felvetel"; } else { echo

"ODBC kapcsolat OK <br><br>"; echo "A PAUTO tabla adatai <br><br>"; $comm = odbc exec($conn, "select * from pauto"); odbc result all($comm); echo "<br><br>"; echo "Nincs tobb adat"; odbc close($conn); } ?> Amint a példából látható előbb a kapcsolatfelvétel történik meg az ODBC adatforrással, ami mögött most egy Oracle DBMS van. A kapcsolat felvételnél megadtuk a DSN nevet, az adatbázis felhasználói nevet és a hozzá tartozó jelszót. A kapcsolatfelvétel sikeressége esetén elküldünk egy SQL ASELECT parancsot végrehajtásra. Az eredményt a legegyszerűbb módon, táblázatos formában jelenítjük meg. A kódrészlet végén lezárjuk a kapcsolatot Ha le szeretnénk futtatni a fenti PHP állományt, akkor a böngészőnkben e dokumentumot kell kérni a WEB szervertől. Természetesen, hogy végre is hajtódjon a kódrészlet, a WEB szervert úgy kell előtte konfigurálni,

hogy felismerje hogy a dokumentumot a PHP szervernek kell feldolgoznia, illetve magának a PHP szervernek is futnia kell már a kiválasztott gépen. A hívás egy lehetséges URL címe: http://laszlo.iituni-miskolchu:88/minta1php A hívás eredményeképpen generált válaszlap a következő formátumú lesz: ODBC kapcsolat OK A PAUTO tabla adatai RSZ r11 rbr234 bh54 bh56 TIPUS opel fiat skoda suzuki AR 2300000 1790000 2600000 1900000 tyu561 opel 4900000 Nincs tobb adat mar Példa 2. Ebben a példában az alaplekérdezés helyett egy szelekciós lekérdezést fogunk végrehajtani. Az autó rekordok közül csak azok fognak megjelenni az eredményben, melyek ára egy megadott ár felett van. A küszöb ár értékét egy indulódokumentum fogja bekérdezni a felhasználótól. Ezen a dokumentumon szerepelnie kell tehát egy beviteli mezőnek az ár megadáshoz és egy nyomógombnak, mely lezárja a bevitelt és meghívja a feldolgozó dokumentumot. A beviteli űrlapot kezelő

dokumentum egy normál HTML dokumentum, míg a feldolgozó dokumentum egy PHP dokumentum lesz, hiszen ez utóbbi esetben lesz szükség adatbázis hozzáférésre. A INDULO.HTM tartalma: <html> <body> <form method = get action = "./minta2php"> Auto adatok lekerdezese <br><br> <table> <tr><td>Minimum ar:</td><td><input type=text name=minar></td></tr> <tr><td> </td><td><input type=submit value="mehet"></td></tr> </table> </form> </body> </html> A dokumentum a meghívásakor az alábbi alakban fog megjelenni a böngészőn: A mehet feliratú gomb aktivizálásakor az ugyanazon könyvtárban lévő MINTA2.PHP fog meghívódni. Ezen PHP dokumentum tartalma a következő: <?php $conn = odbc connect("ORAPROBA","scott","tiger"); if (! $conn) { echo "Hibas ODBC kapcsolat felvetel"; }

else { echo "ODBC kapcsolat OK <br><br>"; echo "A PAUTO tabla adatai <br><br>"; $comm = odbc exec($conn, "select * from pauto where ar > ".$minar); odbc result all($comm); echo "<br><br>"; echo "Nincs tobb adat mar"; odbc close($conn); } ?> Mint látható ez csak annyiban különbözik az előző mintától, hogy az egyszerű SELECT utasítás helyett egy szelekciós feltételt is tartalmaz a lekérdezés. A szelekciós feltételt úgy építettük fel, hogy a SELECT utasítás összeállításakor a küszöbérték helyére a $minar változót tettük be (a . a sztring összefűzés operátora) Ez a változó a hívó, inditó dokumentumban kapott értéket, mivel a ott volt egy ilyen nevű beviteli mező. A válaszlap a következő alakban jelenik meg: Példa 3. Ebben a példában egy összetettebb feladatot hajtunk végre. Az adatbázis tevékenység egy új autó rekord felvitele lesz.

Viszont itt nem egy statikus felviteli úrlapot fogunk használni, hanem dinamikusat. Ugyanis a felviteli úrlapon a három beviteli mezőből az egyik a tipus mező nem normál beviteli mező lesz, hanem egy legördülő választási lista, melynek elemeit az adatbázisból vesszük. Ehhez az adatbázisban létezik egy TIPUSOK tábla, mely az érvényes autó típusokat tartalmazza. Ebből kell kiolvasni a választási lista elemeit A felvitelt szintén egy PHP dokumentum fogja végezni, melyben annyi új elem van, hogy értékellenőrzést is kell végeznie a rendszám mezőre. Egy új autó rekordot csak akkor enged felvinni, ha a rendszáma még nem szerepel a táblában. A feladathoz tehát két, PHP dokumentumot kell készíteni. Az induló felviteli űrlapot az INDULO:PHP generálja, ezt kell majd induláskor meghívni. A rekordot az EPHP dokumentum fogja majd felvinni INDULO.PHP tartalma: <?php echo "Uj auto rekord felvitele<br><br> "; echo

"<form method=get action="e.php"> "; echo "<table> "; echo "<tr><td>Rendszam :</td><td><input type=text name=ursz></td></tr> "; echo "<tr><td>Tipus :</td><td><select name=utip> "; $conn = odbc connect("ORAPROBA","scott","tiger"); if ($conn) { $comm = odbc exec($conn, "SELECT nev FROM tipusok ORDER BY nev"); while (odbc fetch row($comm)) { $v = odbc result($comm,1); echo "<option value="$v"> $v "; } odbc close($conn); } echo "</select></td></tr> "; echo "<tr><td>Ar :</td><td><input type=text name=uar></td></tr> "; echo "<tr><td><input type=submit value=Felvisz></td> <td> </td></tr> "; echo "</table> "; echo "</form> "; ?> A

fenti PHP kód fogja előállítani a felviteli űrlap HTML forrás kódját. Ehhez az echo parancsot használja fel. A sorvégeket itt is a karakterek jelentik A fenti PHP dokumentum lefutása eredményeképpen az alábbi dokumentum áll elő: Uj auto rekord felvitele<br><br> <form method=get action="e.php"> <table> <tr><td>Rendszam :</td><td><input type=text name=ursz></td></tr> <tr><td>Tipus :</td><td><select name=utip> <option value="fiat "> fiat <option value="lada "> lada <option value="mazda "> mazda <option value="opel "> opel <option value="renault "> renault <option value="skoda "> skoda <option value="volvo "> volvo </select></td></tr> <tr><td>Ar :</td><td><input type=text name=uar></td></tr>

<tr><td><input type=submit value=Felvisz></td><td> </td></tr> </table> </form> A lap a böngészőn a következő formában jelenik meg: Ez a lap, amelyet a felhasználó ki fog tölteni, hogy megadja az új rekord mezőinek értékét. A kitöltés után a felvitel a Felvisz feliratú gomb aktivizálával indul el A meghívott felvivő dokumentum kódja: <?php $conn = odbc connect("ORAPROBA","scott","tiger"); if (! $conn) { echo "Hibas ODBC kapcsolat felvetel"; } else { $comm = odbc exec($conn, "select count(*) from pauto where RSZ =".$ursz""); odbc fetch row($comm); $db = odbc result($comm,1); if ($db > 0) { echo "Letezo rendszam, felvitel sikertelen"; } else { $utip = rtrim($utip); $comm = odbc exec($conn, "insert into pauto values($ursz,$utip,$uar)"); if ($comm) { echo "Rekord felveve"; } else { echo "rekord felvitel

sikertelen"; } } odbc close($conn); } ?> A forrásban a kapcsolat felvétele után a db változóba lekérdezzük azon rekordok darabszámát ahol a rendszám mező értéke megegyezik a felvitendő rekord rendszám értékével. Ha találunk ilyen rekordot, akkor nem kerül sor a tényleges felvitelre, mert ismétlődne a rendszám érték, így hibaüzenettel tér vissza a kódszelet. Ha nincs ismétlődés akkor megtörténik az INSERT parancs kiadása, s a művelet sikerességének ellenőrzése