Adatbázisok kezelése MySQL

12. ÓRA Adatbázisok kezelése MySQL A PHP nyelv egyik meghatározó tulajdonsága, hogy nagyon könnyen képes adatbázisokhoz csatlakozni és azokat kezelni. Ebben az órában elsõsorban a MySQL adatbázisokkal foglalkozunk, de amint majd észre fogjuk venni, a PHP által támogatott összes adatbázist hasonló függvények segítségével érhetjük el. Miért esett a választás éppen a MySQL-re? Mert ingyenes, ugyanakkor nagyon hatékony eszköz, amely képes megfelelni a valós feladatok által támasztott igényeknek is. Az sem elhanyagolható szempont, hogy többféle rendszerhez is elérhetõ. A MySQL adatbáziskiszolgálót a http://www.mysql.com címrõl tölthetjük le. Ebben az órában a következõ témákkal foglalkozunk: Megnézünk néhány SQL példát. Csatlakozunk egy MySQL adatbáziskiszolgálóhoz. Kiválasztunk egy adatbázist. Tanulunk a hibakezelésrõl. Adatokat viszünk fel egy táblába.

212 12. óra Adatokat nyerünk ki egy táblából. Megváltoztatjuk egy adattábla tartalmát. Megjelenítjük az adatbázis szerkezetét. (Nagyon) rövid bevezetés az SQL nyelvbe Az SQL jelentése Structured Query Language, vagyis strukturált lekérdezõ nyelv. Az SQL szabványosított nyelvezete segítségével a különbözõ típusú adatbázisokat azonos módon kezelhetjük. A legtöbb SQL termék saját bõvítésekkel látja el a nyelvet, ahogy a legtöbb böngészõ is saját HTML nyelvjárást beszél. Mindazonáltal SQL ismeretek birtokában nagyon sokféle adatbázist fogunk tudni használni, a legkülönbözõbb operációs rendszereken. ÚJDONSÁG A könyvben terjedelmi okok miatt még bevezetõ szinten sem tárgyalhatjuk az SQL-t, de megpróbálunk megvilágítani egy-két dolgot a MySQL-lel és általában az SQL-lel kapcsolatban. A MySQL kiszolgáló démonként fut a számítógépen, így a helyi vagy akár távoli gépek felhasználói bármikor csatlakozhatnak hozzá. Miután a csatlakozás megtörtént, ki kell választanunk a megfelelõ adatbázist, ha van jogunk hozzá. Egy adatbázison belül több adattáblánk is lehet. Minden tábla oszlopokból és sorokból áll. A sorok és oszlopok metszéspontjában tároljuk az adatokat. Minden oszlopba csak elõre megadott típusú adatot tölthetünk, az INT típus például egész számot, míg a VARCHAR változó hosszúságú, de egy adott értéknél nem hosszabb karakterláncot jelent. A kiválasztott adatbázisban a következõ SQL utasítással hozhatunk létre új táblát: CREATE TABLE entablam ( keresztnev VARCHAR(30), å vezeteknev VARCHAR(30), kor INT ); Ez a tábla három oszlopot tartalmaz. A keresztnev és vezeteknev oszlopokba legfeljebb 30 karaktert írhatunk, míg a kor oszlopba egy egész számot. A táblába új sort az INSERT paranccsal vehetünk fel: INSERT INTO entablam ( keresztnev, vezeteknev, kor ) å VALUES ( 'János', 'Kovács', 36 );

Adatbázisok kezelése MySQL 213 A mezõneveket az elsõ, zárójelek közti kifejezéssel adjuk meg, míg az értékeket a megfelelõ sorrendben a második zárójelpár között soroljuk fel. A táblából az összes adatot a SELECT paranccsal kaphatjuk meg: SELECT * FROM entablam; A * szokásos helyettesítõ karakter, jelentése az összes mezõ. Ha nem az összes mezõ tartalmát akarjuk lekérdezni, írjuk be az érintett mezõk neveit a csillag helyére: SELECT kor, keresztnev FROM entablam; Már létezõ bejegyzést az UPDATE paranccsal módosíthatunk. UPDATE entablam SET keresztnev = 'Gábor'; Az utasítás az összes sorban "Gábor"-ra módosítja a keresztnev mezõ tartalmát. A WHERE záradékkal leszûkíthetjük a SELECT és UPDATE parancsok hatáskörét. Például: SELECT * FROM entablam WHERE keresztnev = 'Gábor'; 12 Ez az utasítás csak azokat a sorokat írja ki, amelyekben a keresztnev mezõ értéke "Gábor". A következõ példa csak azokban a sorokban változtatja "Gábor"-ra a keresztnev mezõ értékét, ahol a vezeteknev mezõ a "Szakács" karakterláncot tartalmazza. UPDATE entablam SET keresztnev = "Gábor" WHERE vezeteknev = å = "Szakács"; Az SQL-rõl további információkat találunk Ryan K. Stephens és szerzõtársai Teach Yourself SQL in 21 Days címû könyvében. Csatlakozás a kiszolgálóhoz Mielõtt elkezdhetnénk dolgozni az adatbázissal, csatlakoznunk kell a kiszolgálóhoz. A PHP-ben erre a mysql_connect() függvény szolgál. A függvény három karakterláncot vár paraméterként: a gazdagép nevét, a felhasználó nevét és a jelszót. Ha ezek egyikét sem adjuk meg, a függvény feltételezi, hogy a kérés a localhost-ra (azaz a helyi gépre) vonatkozik és felhasználóként a PHP-t futtató felhasználót, jelszóként pedig egy üres karakterláncot ad át. Az alapértelmezés

214 12. óra a php.ini fájlban felülbírálható, de egy próbálkozásra szánt kiszolgálót kivéve nem bölcs dolog ezzel próbálkozni, ezért a példákban mindig használni fogjuk a felhasználónevet és a jelszót. A mysql_connect() függvény siker esetén egy kapcsolatazonosítót ad vissza, amelyet egy változóba mentünk, hogy a késõbbiekben folytathassuk a munkát az adatbáziskiszolgálóval. Az alábbi kódrészlet a mysql_connect() függvény segítségével kapcsolódik a MySQL adatbáziskiszolgálóhoz. $kapcsolat = mysql_connect( "localhost", "root", "jelszo" ); if (! $kapcsolat ) die( "Nem lehet csatlakozni a MySQL kiszolgalohoz!" ); Ha a PHP-t az Apache kiszolgáló moduljaként használjuk, a mysql_pconnect() függvényt is használhatjuk az elõzõekben megadott paraméterekkel. Fontos különbség a két függvény között, hogy a mysql_pconnect()-tel megnyitott adatbáziskapcsolat nem szûnik meg a PHP program lefutásával vagy a mysql_close() függvény hatására (amely egy szokásos MySQL kiszolgálókapcsolat bontására szolgál), hanem továbbra is aktív marad és olyan programokra várakozik, amelyek a mysql_pconnect() függvényt hívják. Más szóval a mysql_pconnect() függvény használatával megtakaríthatjuk azt az idõt, ami egy kapcsolat felépítéséhez szükséges és egy elõzõleg lefutott program által hagyott azonosítót használhatunk. Az adatbázis kiválasztása Miután kialakítottuk a kapcsolatot a MySQL démonnal, ki kell választanunk, melyik adatbázissal szeretnénk dolgozni. Erre a célra a mysql_select_db() függvény szolgál, amelynek meg kell adnunk a kiválasztott adatbázis nevét és szükség szerint egy kapcsolatazonosító értéket. Ha ez utóbbit elhagyjuk, automatikusan a legutoljára létrehozott kapcsolat helyettesítõdik be. A mysql_select_db() függvény igaz értéket ad vissza, ha az adatbázis létezik és jogunk van a használatára. A következõ kódrészlet a pelda nevû adatbázist választja ki. $adatbazis = "pelda"; mysql_select_db( $adatbazis ) or die ( "Nem lehet å megnyitni a következõ adatbázist: $adatbazis" );

Adatbázisok kezelése MySQL 215 Hibakezelés Eddig ellenõriztük a MySQL függvények visszatérési értékét és hiba esetén a die() függvénnyel kiléptünk a programból. A hibakezeléshez azonban hasznosabb lenne, ha a hibaüzenetek valamivel több információt tartalmaznának. Ha valamilyen mûvelet nem sikerül, a MySQL beállít egy hibakódot és egy hibaüzenetet. A hibakódhoz a mysql_errno(), míg a hibaüzenethez a mysql_error() függvénnyel férhetünk hozzá. A 12.1 példa az eddigi kódrészleteinket teljes programmá kapcsolja össze, amely kapcsolódik az adatbáziskezelõhöz és kiválasztja az adatbázist. A hibaüzenetet a mysql_error() függvénnyel tesszük használhatóbbá. 12.1. program Kapcsolat megnyitása és az adatbázis kiválasztása 1: <html> 2: <head> 3: <title>12.1. program Kapcsolat megnyitása és 4: adatbázis kiválasztása</title> 5: </head> 6: <body> 7: <?php 8: $felhasznalo = "jozsi"; 9: $jelszo = "bubosvocsok"; 10: $adatbazis = "pelda"; 11: $kapcsolat = mysql_connect( "localhost", $felhasznalo, $jelszo ); 12: if (! $kapcsolat ) 13: die( "Nem lehet kapcsolódni a MySQL kiszolgálóhoz!" ); 14: print "Sikerült a kapcsolatfelvétel<p>"; 15: mysql_select_db( $adatbazis ) 16: or die ( "Nem lehet megnyitni a $adatbázist: ".mysql_error() ); 17: print "Sikeresen kiválasztott adatbázis: \" $adatbazis\"<p>"; 18: mysql_close( $kapcsolat ); 19:?> 20: </body> 21: </html> 12

216 12. óra Ha az $adatbazis változó értékét mondjuk "nincsmeg"-re módosítjuk, a program egy nem létezõ adatbázist próbál meg elérni. Ekkor a die() kimenete valami ilyesmi lesz: Nem lehet megnyitni a nincsmeg adatbázist: Access denied å for user: 'jozsi@localhost' to database 'nincsmeg' Adatok hozzáadása táblához Már sikerült hozzáférést szerezni az adatbázishoz, így ideje némi adatot is bevinni a táblákba. A következõ példákhoz képzeljük el, hogy az általunk készítendõ oldalon a látogatóknak lehetõségük lesz tartományneveket vásárolni. A pelda adatbázisban készítsük el az öt oszlopot tartalmazó tartomanyok táblát. Az azonosito mezõ lesz az elsõdleges kulcs, amely automatikusan növel egy egész értéket, ahogy újabb bejegyzések kerülnek a táblába, a tartomany mezõ változó számú karaktert tartalmazhat (VARCHAR), a nem mezõ egyetlen karaktert, az email mezõ pedig a felhasználó elektronikus levélcímét. A táblát a következõ SQL paranccsal készíthetjük el: CREATE TABLE tartomanyok ( azonosito INT NOT NULL å AUTO_INCREMENT, PRIMARY KEY( azonosito ), tartomany VARCHAR( 20 ), nem CHAR( 1 ), email VARCHAR( 20 ) ); Az adatok felviteléhez össze kell állítanunk és le kell futtatnunk egy SQL parancsot, erre a célra a PHP-ben a mysql_query() függvény szolgál. A függvény paraméterként egy SQL parancsot tartalmazó karakterláncot és szükség szerint egy kapcsolatazonosítót vár. Ha ez utóbbit elhagyjuk, a függvény automatikusan az utoljára megnyitott kapcsolaton keresztül próbálja meg kiadni az SQL parancsot. Ha a program sikeresen lefutott, a mysql_query()pozitív értéket ad vissza, ha azonban formai hibát tartalmaz vagy nincs jogunk elérni a kívánt adatbázist, a visszatérési érték hamis lesz. Meg kell jegyeznünk, hogy egy sikeresen lefutott SQL program nem feltétlenül okoz változást az adatbázisban vagy tér vissza valamilyen eredménnyel. A 12.2 példában kibõvítjük a korábbi programot és a mysql_query() függvénnyel kiadunk egy INSERT utasítást a pelda adatbázis tartomanyok tábláján.

Adatbázisok kezelése MySQL 217 12.2. program Új sor hozzáadása táblához 1: <html> 2: <head> 3: <title>12.2. program Új sor hozzáadása táblához</title> 4: </head> 5: <body> 6: <?php 7: $felhasznalo = "jozsi"; 8: $jelszo = "bubosvocsok"; 9: $adatbazis = "pelda"; 10: $kapcsolat = mysql_connect( "localhost", $felhasznalo, $jelszo ); 11: if (! $kapcsolat ) 12: die( "Nem lehet kapcsolódni a MySQL kiszolgálóhoz!" ); 13: mysql_select_db( $adatbazis, $kapcsolat ) 14: or die ( "Nem lehet megnyitni a $adatbázist: ".mysql_error() ); 15: $parancs = "INSERT INTO tartomanyok ( tartomany, nem, email ) 16: VALUES ( '123xyz.com', 'F', 'okoska@tartomany.hu' )"; 17: mysql_query( $parancs, $kapcsolat ) 18: or die ( "Nem lehet adatot hozzáadni a \"tartomanyok\" táblához: " 19:.mysql_error() ); 20: mysql_close( $kapcsolat ); 21:?> 22: </body> 23: </html> 12 Vegyük észre, hogy nem adtunk értéket az azonosito mezõnek. A mezõ értéke automatikusan növekszik az INSERT hatására. Természetesen minden esetben, amikor a böngészõben újratöltjük a 12.2 példaprogramot, ugyanaz a sor adódik hozzá a táblához. A 12.3 példa a felhasználó által bevitt adatot tölti be a táblába.

218 12. óra 12.3.program A felhasználó által megadott adatok beszúrása a táblába 1: <html> 2: <head> 3: <title>12.3. program A felhasználó által megadott adatok beszúrása a táblába</title> 4: </head> 5: <body> 6: <?php 7: if ( isset( $tartomany ) && isset( $nem ) && isset( $email ) ) 8: { 9: // Ne feledjük ellenõrizni a felhasználó által megadott adatokat! 10: $dbhiba = ""; 11: $vissza = adatbazis_bovit( $tartomany, $nem, $email, $dbhiba ); 12: if (! $vissza ) 13: print "Hiba: $dbhiba<br>"; 14: else 15: print "Köszönjük!"; 16: } 17: else { 18: urlap_keszit(); 19: } 20: 21: function adatbazis_bovit( $tartomany, $nem, $email, &$dbhiba ) 22: { 23: $felhasznalo = "jozsi"; 24: $jelszo = "bubosvocsok"; 25: $adatbazis = "pelda"; 26: $kapcsolat = mysql_pconnect( "localhost", $felhasznalo, $jelszo ); 27: if (! $kapcsolat ) 28: { 29: $dbhiba = "Nem lehet kapcsolódni a MySQL kiszolgálóhoz!"; 30: return false; 31: } 32: if (! mysql_select_db( $adatbazis, $kapcsolat ) ) 33: { 34: $dbhiba = mysql_error();

Adatbázisok kezelése MySQL 219 12.3.program (folytatás) 35: return false; 36: } 37: $parancs = "INSERT INTO tartomanyok ( tartomany, nem, email ) 38: VALUES ( '$tartomany', '$nem', '$email' )"; 39: if (! mysql_query( $parancs, $kapcsolat ) ) 40: { 41: $dbhiba = mysql_error(); 42: return false; 43: } 44: return true; 45: } 46: 47: function urlap_keszit() 48: { 49: global $PHP_SELF; 50: print "<form action=\"$php_self\" method=\"post\">\n"; 51: print "A kívánt tartomány<p>\n"; 52: print "<input type=\"text\" name=\"tartomany\"> "; 53: print "Email cím<p>\n"; 54: print "<input type=\"text\" name=\"email\"> "; 55: print "<select name=\"nem\">\n"; 56: print "\t<option value=\"n\"> Nõ\n"; 57: print "\t<option value=\"f\"> Férfi\n"; 58: print "</select>\n"; 59: print "<input type=\"submit\" value=\"elküld\">\n</form>\n"; 60: } 61:?> 62: </body> 63: </html> 12 A tömörség érdekében a 12.3. példából kihagytunk egy fontos részt. Megbíztunk a felhasználókban: semmilyen formában nem ellenõriztük a felhasználó által bevitt adatokat. Ezt a feladatot a 17. órában tárgyalt karakterlánckezelõ függvényekkel végezhetjük el. Meg kell jegyeznünk, hogy a beérkezõ adatok ellenõrzése mindig fontos feladat, itt csak azért maradt el, mivel így jobban összpontosíthattunk az óra témájára.

220 12. óra Ellenõrizzük a $tartomany, $nem és $email változókat. Ha megvannak, nyugodtan feltehetjük, hogy a felhasználó adatokat küldött az ûrlap kitöltésével, így meghívjuk az adatbazis_bovit() függvényt. Az adatbazis_bovit()-nek négy paramétere van: a $tartomany, a $nem és az $email változók, illetve a $dbhiba karakterlánc. Ez utóbbiba fogjuk betölteni az esetlegesen felbukkanó hibaüzeneteket, így hivatkozásként kell átadnunk. Ennek hatására ha a függvénytörzsön belül megváltoztatjuk a $dbhiba értékét, a másolat helyett tulajdonképpen az eredeti paraméter értékét módosítjuk. Elõször megkísérlünk megnyitni egy kapcsolatot a MySQL kiszolgálóhoz. Ha ez nem sikerül, akkor hozzárendelünk egy hibaszöveget a $dbhiba változóhoz és false értéket visszaadva befejezzük a függvény futását. Ha a csatlakozás sikeres volt, kiválasztjuk a tartomany táblát tartalmazó adatbázist és összeállítunk egy SQL utasítást a felhasználó által küldött értékek felhasználásával, majd az utasítást átadjuk a mysql_query() függvénynek, amely elvégzi az adatbázisban a kívánt mûveletet. Ha a mysql_select_db() vagy a mysql_query() függvény nem sikeres, a $dbhiba változóba betöltjük a mysql_error() függvény által visszaadott értéket és false értékkel térünk vissza. Minden egyéb esetben, vagyis ha a mûvelet sikeres volt, true értéket adunk vissza. Miután az adatbazis_bovit() lefutott, megvizsgáljuk a visszatérési értéket. Ha true, az adatok bekerültek az adatbázisba, így üzenetet küldhetünk a felhasználónak. Egyébként ki kell írnunk a böngészõbe a hibaüzenetet. Az adatbazis_bovit() függvény által visszaadott $dbhiba változó most már hasznos adatokat tartalmaz a hiba természetét illetõen, így ezt a szöveget is belefoglaljuk a hibaüzenetbe. Ha a kezdeti if kifejezés nem találja meg a $tartomany, $nem vagy $email valamelyikét, feltehetjük, hogy a felhasználó nem küldött el semmilyen adatot, ezért meghívunk egy másik általunk írt függvényt, az urlap_keszit()-et, amely egy HTML ûrlapot jelenít meg a böngészõben. Automatikusan növekvõ mezõ értékének lekérdezése Az elõzõ példákban úgy adtuk hozzá a sorokat a táblához, hogy nem foglalkoztunk az azonosito oszlop értékével, hiszen az adatok beszúrásával az folyamatosan növekedett, értékére pedig nem volt szükségünk. Ha mégis szükségünk lenne rá, egy SQL lekérdezéssel bármikor lekérdezhetjük az adatbázisból. De mi van akkor, ha azonnal szükségünk van az értékre? Fölösleges külön lekérdezést végrehajtani, hiszen a PHP tartalmazza a mysql_insert_id() függvényt, amely a legutóbbi INSERT kifejezés során beállított automatikusan növelt mezõ értékét adja vissza. A mysql_insert_id() függvénynek szükség esetén átadhatunk

Adatbázisok kezelése MySQL 221 egy kapcsolatazonosító paramétert, amelyet elhagyva a függvény alapértelmezés szerint a legutoljára létrejött MySQL kapcsolat azonosítóját használja. Így ha meg akarjuk mondani a felhasználónak, hogy milyen azonosító alatt rögzítettük az adatait, az adatok rögzítése után közvetlenül hívjuk meg a mysql_insert_id() függvényt. $parancs = "INSERT INTO tartomanyok ( tartomany, nem, å email ) VALUES ( '$tartomany', '$nem', '$email' )"; mysql_query( $parancs, $kapcsolat ); $azonosito = mysql_insert_id(); print "Köszönjük. Az Ön tranzakció-azonosítója: å $azonosito. Kérjük jegyezze meg ezt a kódot."; Adatok lekérdezése Miután adatainkat már képesek vagyunk az adatbázisban tárolni, megismerkedhetünk azokkal a módszerekkel, amelyek az adatok visszanyerésére szolgálnak. Mint bizonyára már nyilvánvaló, a mysql_query() függvény használatával ki kell adnunk egy SELECT utasítást. Az azonban már korántsem ilyen egyszerû, hogyan jutunk hozzá a lekérdezés eredményéhez. Nos, miután végrehajtottunk egy sikeres SELECT-et, a mysql_query() visszaad egy úgynevezett eredményazonosítót, melynek felhasználásával elérhetjük az eredménytáblát és információkat nyerhetünk róla. 12 Az eredménytábla sorainak száma A SELECT utasítás eredményeként kapott tábla sorainak számát a mysql_num_rows() függvény segítségével kérdezhetjük le. A függvény paramétere a kérdéses eredmény azonosítója, visszatérési értéke pedig a sorok száma a táblában. A 12.4. példaprogramban lekérdezzük a tartomany tábla összes sorát és a mysql_num_rows() függvénnyel megkapjuk a teljes tábla méretét. 12.4. program Sorok száma a SELECT utasítás eredményében. 1: <html> 2: <head> 3: <title>12.4. program A mysql_num_rows() függvény használata</title> 4: </head> 5: <body> 6: <?php

222 12. óra 12.4. program (folytatás) 7: $felhasznalo = "jozsi"; 8: $jelszo = "bubosvocsok"; 9: $adatbazis = "pelda"; 10: $kapcsolat = mysql_connect( "localhost", $felhasznalo, $jelszo ); 11: if (! $kapcsolat ) 12: die( "Nem lehet kapcsolódni a MySQL kiszolgálóhoz!" ); 13: mysql_select_db( $adatbazis, $kapcsolat ) 14: or die ( "Nem lehet megnyitni a $adatbazis adatbázist: ".mysql_error() ); 15: $eredmeny = mysql_query( "SELECT * FROM tartomanyok" ); 16: $sorok_szama = mysql_num_rows( $eredmeny ); 17: print "Jelenleg $sorok_szama sor van a táblában<p>"; 18: mysql_close( $kapcsolat ); 19:?> 20: </body> 21: </html> A mysql_query() függvény egy eredményazonosítót ad vissza. Ezt átadjuk a mysql_num_rows() függvénynek, amely megadja a sorok számát. Az eredménytábla elérése Miután végrehajtottuk a SELECT lekérdezést és az eredményazonosítót tároltuk, egy ciklus segítségével férhetünk hozzá az eredménytábla soraihoz. A PHP egy belsõ mutató segítségével tartja nyilván, hogy melyik sort olvastuk utoljára. Ha kiolvasunk egy eredménysort, a program automatikusan a következõre ugrik. A mysql_fetch_row() függvénnyel kiolvashatjuk a belsõ mutató által hivatkozott sort az eredménytáblából. A függvény paramétere egy eredményazonosító, visszatérési értéke pedig egy tömb, amely a sor összes mezõjét tartalmazza. Ha elértük az eredménykészlet végét, a mysql_fetch_row() függvény false értékkel tér vissza. A 12.5. példa a teljes tartomany táblát megjeleníti a böngészõben.

Adatbázisok kezelése MySQL 223 12.5. program Tábla összes sorának és oszlopának megjelenítése 1: <html> 2: <head> 3: <title>12.5. program Tábla összes sorának és oszlopának megjelenítése</title> 4: </head> 5: <body> 6: <?php 7: $felhasznalo = "jozsi"; 8: $jelszo = "bubosvocsok"; 9: $adatbazis = "pelda"; 10: $kapcsolat = mysql_connect( "localhost", $felhasznalo, $jelszo ); 11: if (! $kapcsolat ) 12: die( "Nem lehet kapcsolódni a MySQL kiszolgálóhoz!" ); 13: mysql_select_db( $db, $kapcsolat ) 14: or die ( "Nem lehet megnyitni a $adatbazis adatbázist: ".mysql_error() ); 15: $eredmeny = mysql_query( "SELECT * FROM tartomanyok" ); 16: $sorok_szama = mysql_num_rows( $eredmeny ); 17: print "Jelenleg $sorok_szama sor van a táblában<p>"; 18: print "<table border=1>\n"; 19: while ( $egy_sor = mysql_fetch_row( $eredmeny ) ) 20: { 21: print "<tr>\n"; 22: foreach ( $egy_sor as $mezo ) 23: print "\t<td>$mezo</td>\n"; 24: print "</tr>\n"; 25: } 26: print "</table>\n"; 27: mysql_close( $kapcsolat ); 28:?> 29: </body> 30: </html> 12 Kapcsolódunk a kiszolgálóhoz és kiválasztjuk az adatbázist, majd a mysql_query() függvénnyel egy SELECT lekérdezést küldünk az adatbázis kiszolgálójához. Az eredményt az $eredmeny változóban tároljuk, amit az eredménysorok számának lekérdezéséhez használunk, ahogy korábban láttuk.

224 12. óra A while kifejezésben a mysql_fetch_row() függvény visszatérési értékét az $egy_sor változóba töltjük. Ne feledjük, hogy az értékadó kifejezés értéke megegyezik a jobb oldal értékével, ezért a kiértékelés során a kifejezés értéke mindig igaz lesz, amíg a mysql_fetch_row() függvény nem nulla értékkel tér vissza. A ciklusmagban kiolvassuk az $egy_sor változóban tárolt elemeket és egy táblázat celláiként jelenítjük meg azokat a böngészõben. A mezõket név szerint is elérhetjük, méghozzá kétféle módon. A mysql_fetch_array() függvény egy asszociatív tömböt ad vissza, ahol a kulcsok a mezõk nevei. A következõ kódrészletben módosítottuk a 12.5. példa while ciklusát, a mysql_fetch_array() függvény felhasználásával: print "<table border=1>\n"; while ( $egy_sor = mysql_fetch_array( $eredmeny ) ) { print "<tr>\n"; print "<td>".$egy_sor["email"]."</td><td>".$egy_sor["tartomany"]. å "</td>\n"; print "</tr>\n"; } print "</table>\n"; A mysql_fetch_object() függvény segítségével egy objektum tulajdonságaiként férhetünk hozzá a mezõkhöz. A mezõnevek lesznek a tulajdonságok nevei. A következõ kódrészletben ismét módosítottuk a kérdéses részt, ezúttal a mysql_fetch_object() függvényt használtuk. print "<table border=1>\n"; while ( $egy_sor = mysql_fetch_object( $eredmeny ) ) { print "<tr>\n"; print "<td>".$egy_sor->email."</td><td>".$egy_sor-> å tartomany."</td>\n"; print "</tr>\n"; } print "</table>\n"; A mysql_fetch_array() és mysql_fetch_object() függvények lehetõvé teszik számunkra, hogy a sorból kinyert információkat szûrjük és végrehajtásuk sem kerül sokkal több idõbe, mint a mysql_fetch_row() függvényé.

Adatbázisok kezelése MySQL 225 Adatok frissítése Az adatokat az UPDATE utasítással frissíthetjük, amelyet természetesen a mysql_query() függvénnyel kell átadnunk az adatbázis kiszolgálójának. Itt is igazak a korábban elmondottak, azaz egy sikeres UPDATE utasítás nem feltétlenül jelent változást az adatokban. A megváltozott sorok számát a mysql_affected_rows() függvénnyel kérdezhetjük le, amelynek szükség szerint egy kapcsolatazonosítót kell átadnunk. Ennek hiányában a függvény mint azt már megszokhattuk a legfrissebb kapcsolatra értelmezi a mûveletet. A mysql_affected_rows() függvényt bármely olyan SQL lekérdezés után használhatjuk, amely feltehetõen módosított egy vagy több sort az adattáblában. A 12.6. példa egy olyan programot tartalmaz, amely lehetõvé teszi az adatbázis karbantartója számára, hogy bármelyik sor tartomany mezõjét megváltoztassa. 12.6. program Sorok frissítése az adatbázisban 1: <html> 2: <head> 3: <title>12.6. program Sorok frissítése az adatbázisban 4: </title> 5: </head> 6: <body> 7: <?php 8: $felhasznalo = "jozsi"; 9: $jelszo = "bubosvocsok"; 10: $adatbazis = "pelda"; 11: $kapcsolat = mysql_connect( "localhost", $felhasznalo, $jelszo ); 12: if (! $kapcsolat ) 13: die( "Nem lehet kapcsolódni a MySQL kiszolgálóhoz! ); 14: mysql_select_db( $adatbazis, $kapcsolat ) 15: or die ( "Nem lehet megnyitni a $adatbazis adatbázist: ".mysql_error() ); 16: if ( isset( $tartomany ) && isset( $azonosito ) ) 17: { 18: $parancs = "UPDATE tartomanyok SET tartomany = '$tartomany' WHERE azonosito=$azonosito"; 19: $eredmeny = mysql_query( $parancs ); 12

226 12. óra 12.6. program (folytatás) 20: if (! $eredmeny ) 21: die ("Nem sikerült a módosítás: ".mysql_error()); 22: print "<h1>a tábla módosítva, ". mysql_affected_rows(). 23: " sor változott</h1><p>"; 24: } 25:?> 26: <form action="<? print $PHP_SELF?>" method="post"> 27: <select name="azonosito"> 28: <? 29: $eredmeny = mysql_query( "SELECT tartomany, azonosito FROM tartomanyok" ); 30: while( $egy_sor = mysql_fetch_object( $eredmeny ) ) 31: { 32: print "<option value=\"$egy_sor->azonosito\""; 33: if ( isset($azonosito) && $azonosito == $egy_sor->azonosito ) 34: print " selected"; 35: print "> $egy_sor->tartomany\n"; 36: } 37: mysql_close( $kapcsolat ); 38:?> 39: </select> 40: <input type="text" name="tartomany"> 41: <input type="submit" value="frissítés"> 42: </form> 43: </body> 44: </html> A mûvelet a szokásos módon indul: kapcsolódunk az adatbázis kiszolgálójához és kiválasztjuk az adatbázist. Ezek után megvizsgáljuk a $tartomany és az $azonosito változók meglétét. Ha mindent rendben találunk, összeállítjuk az SQL utasítást, amely a $tartomany változó értékének megfelelõen frissíti azt a sort, ahol az azonosito mezõ tartalma megegyezik az $azonosito változó értékével. Ha nem létezõ azonosito értékre hivatkozunk vagy a kérdéses sorban a $tartomany változó értéke megegyezik a tartomany mezõ tartalmával, nem kapunk hibaüzenetet, de a mysql_affected_rows() függvény visszatérési értéke 0 lesz. A módosított sorok számát kiírjuk a böngészõbe.

Adatbázisok kezelése MySQL 227 A karbantartó számára készítünk egy HTML ûrlapot, amelyen keresztül elvégezheti a változtatásokat. Ehhez ismét a mysql_query() függvényt kell használnunk: lekérdezzük az azonosito és tartomany oszlopok összes elemét és beillesztjük azokat egy HTML SELECT listába. A karbantartó ezáltal egy lenyíló menübõl választhatja ki, melyik bejegyzést kívánja módosítani. Ha a karbantartó már elküldte egyszer az ûrlapot, akkor az utoljára hivatkozott azonosito érték mellé a SELECTED módosítót is kitesszük, így a módosítások azonnal látszódni fognak a menüben. Információk az adatbázisokról Mindezidáig egyetlen adatbázisra összpontosítottunk, megtanulva, hogyan lehet adatokkal feltölteni egy táblát és az adatokat lekérdezni. A PHP azonban számos olyan eszközzel szolgál, amelyek segítségével megállapíthatjuk, hány adatbázis hozzáférhetõ az adott kapcsolaton keresztül és milyen ezek szerkezete. Az elérhetõ adatbázisok kiíratása A mysql_list_dbs() függvény segítségével listát kérhetünk az összes adatbázisról, melyek az adott kapcsolaton keresztül hozzáférhetõk. A függvény paramétere szükség szerint egy kapcsolatazonosító, visszatérési értéke pedig egy eredményazonosító. Az adatbázisok neveit a mysql_tablename() függvénnyel kérdezhetjük le, amelynek paramétere ez az eredményazonosító és az adatbázis sorszáma, visszatérési értéke pedig az adatbázis neve. Az adatbázisok sorszámozása 0-val kezdõdik. Az összes adatbázis számát a mysql_list_dbs() függvény után meghívott mysql_num_rows() függvény adja meg. 12 12.7. program Adott kapcsolaton keresztül elérhetõ adatbázisok 1: <html> 2: <head> 3: <title>12.7. program Adott kapcsolaton keresztül elérhetõ adatbázisok 4: </title> 5: </head> 6: <body> 7: <?php 8: $felhasznalo = "jozsi"; 9: $jelszo = "bubosvocsok"; 10: $kapcsolat = mysql_connect( "localhost", $felhasznalo, $jelszo );

228 12. óra 12.7. program (folytatás) 11: if (! $kapcsolat ) 12: die( "Nem lehet kapcsolódni a MySQL kiszolgálóhoz!" ); 13: $adatbazis_lista = mysql_list_dbs( $kapcsolat ); 14: $szam = mysql_num_rows( $adatbazis_lista ); 15: for( $x = 0; $x < $szam; $x++ ) 16: print mysql_tablename( $adatbazis_lista, $x )."<br>"; 17: mysql_close( $kapcsolat ); 18:?> 19: </body> 20: </html> A mysql_list_dbs() függvény visszaad egy eredményazonosítót, amelyet paraméterként átadunk a mysql_num_rows() függvénynek. Az így megkapott adatbázisok számát a $szam változóba töltjük és felhasználjuk a for ciklusban. Az $x indexet minden lépésben eggyel növeljük, 0-tól a talált adatbázisok számáig, majd az eredményazonosítóval együtt átadjuk a mysql_tablename() függvénynek az adatbázis nevének lekérdezéséhez. A 12.1 ábrán a 12.7 program eredménye látható egy böngészõablakban. 12.1. ábra Az elérhetõ adatbázisok listája

Adatbázisok kezelése MySQL 229 A mysql_list_dbs() függvény által visszaadott eredményazonosítót a mysql_query() eredményéhez hasonlóan is felhasználhatnánk, vagyis a tényleges neveket a mysql_fetch_row() függvénnyel is lekérdezhetnénk. Ekkor eredményül egy tömböt kapnánk, melynek elsõ eleme tartalmazná az adatbázis nevét. Adatbázistáblák listázása A mysql_list_tables() függvénnyel egy adott adatbázis tábláinak nevét soroltathatjuk fel. A függvény paraméterei az adatbázis neve és szükség szerint a kapcsolat azonosítója. A visszatérési érték egy eredményazonosító, ha az adatbázis létezik és jogunk van hozzáférni. Az eredményazonosítót mysql_tablename() vagy mysql_fetch_row() hívásokhoz használhatjuk fel, a fent látott módon. A következõ kódrészlet a mysql_list_tables() függvény segítségével az adatbázis összes tábláját kiírja. $eredmeny = mysql_list_tables( "pelda", $kapcsolat ); while ( $tabla_sor = mysql_fetch_row( $eredmeny ) ) print $tabla_sor[0]."<br>\n"; 12 Információk a mezõkrõl A SELECT lekérdezés után az eredménytábla mezõinek számát a mysql_num_fields() függvénnyel kaphatjuk meg. A függvény paramétere egy eredményazonosító, visszatérési értéke pedig egy egész szám, amely a mezõk számát adja meg. $eredmeny = mysql_query( "SELECT * from tartomanyok" ); $mezok_szama = mysql_num_fields( $eredmeny ); A mezõkhöz sorszámokat rendelünk, a számozás 0-val kezdõdik. A sorszám és az eredményazonosító alapján számos információt lekérdezhetünk a mezõrõl, beleértve a nevét, típusát, legnagyobb hosszát és egyéb jellemzõit is. A mezõ nevének lekérdezésére a mysql_field_name() függvény szolgál. $eredmeny = mysql_query( "SELECT * from tartomanyok" ); $mezok_szama = mysql_num_fields( $eredmeny ); for ( $x=0; $x<$mezok_szama; $x++ ) mysql_field_name( $eredmeny, $x ). "<br>\n";

230 12. óra A mezõ legnagyobb hosszát a mysql_field_len() függvénnyel kaphatjuk meg. $eredmeny = mysql_query( "SELECT * from tartomanyok" ); $mezok_szama = mysql_num_fields( $eredmeny ); for ( $x=0; $x<$mezok_szama; $x++ ) mysql_field_len( $eredmeny, $x ). "<BR>\n"; A mezõ egyéb jellemzõit a mysql_field_flags() függvénnyel olvashatjuk ki: $eredmeny = mysql_query( "SELECT * from tartomanyok" ); $mezok_szama = mysql_num_fields( $eredmeny ); for ( $x=0; $x<$mezok_szama; $x++ ) mysql_field_flags( $eredmeny, $x ). "<BR>\n"; Lehetõségünk van még a mezõ típusának megállapítására, a mysql_field_type() függvénnyel: $eredmeny = mysql_query( "SELECT * from tartomanyok" ); $mezok_szama = mysql_num_fields( $eredmeny ); for ( $x=0; $x<$mezok_szama; $x++ ) mysql_field_type( $eredmeny, $x ). "<BR>\n"; Az adatbázis szerkezete összeáll a kép A 12.8 példa egyesíti a fenti eljárásokat és megjelenít minden elérhetõ adatbázist, táblát és mezõt. 12.8 program Minden adatbázis, tábla és mezõ megjelenítése 1: <html> 2: <head> 3: <title>12.8. program Minden adatbázis, tábla és mezõ megjelenítése</title> 4: </head> 5: <body> 6: <?php 7: $felhasznalo = "root"; 8: $jelszo = "titkos"; 9: $kapcsolat = mysql_connect( "localhost", $felhasznalo, $jelszo );

Adatbázisok kezelése MySQL 231 12.8 program (folytatás) 10: if (! $kapcsolat ) 11: die( "Nem lehet kapcsolódni a MySQL kiszolgálóhoz!" ); 12: $adatbazis_lista = mysql_list_dbs( $kapcsolat ); 13: while ( $adatbazisok = mysql_fetch_row ( $adatbazis_lista ) ) 14: { 15: print "<b>".$adatbazisok[0]."</b>\n"; 16: if (!@mysql_select_db( $adatbazisok[0], $kapcsolat ) ) 17: { 18: print "<dl><dd>nem lehet kiválasztani ". mysql_error()." </dl>"; 19: continue; 20: } 21: $tablak = mysql_list_tables( $adatbazisok[0], $kapcsolat ); 22: print "\t<dl><dd>\n"; 23: while ( $tabla_sor = mysql_fetch_row( $tablak ) ) 24: { 25: print "\t<b>$tabla_sor[0]</b>\n"; 26: $eredmeny = mysql_query( "SELECT * from ".$tabla_sor[0] ); 12 27: $mezok_szama = mysql_num_fields( $eredmeny ); 28: print "\t\t<dl><dd>\n"; 29: for ( $x=0; $x<$mezok_szama; $x++ ) 30: { 31: print "\t\t<i>"; 32: print mysql_field_type( $eredmeny, $x ); 33: print "</i> <i>"; 34: print mysql_field_len( $eredmeny, $x ); 35: print "</i> <b>"; 36: print mysql_field_name( $eredmeny, $x ); 37: print "</b> <i>"; 38: print mysql_field_flags( $eredmeny, $x ); 39: print "</i><br>\n"; 40: } 41: print "\t\t</dl>\n"; 42: }

232 12. óra 12.8 program (folytatás) 43: print "\t</dl>\n"; 44: } 45: mysql_close( $kapcsolat ); 46:?> 47: </body> 48: </html> Elõször is a szokásos módon a MySQL kiszolgálóhoz kapcsolódunk, majd meghívjuk a mysql_list_dbs() függvényt. A kapott eredményazonosítót átadjuk a mysql_fetch_row() függvénynek és az $adatbazisok tömb elsõ elemébe betöltjük az aktuális adatbázis nevét. Ezután megpróbáljuk kiválasztani az adatbázist a mysql_select_db() függvénnyel. Ha nincs hozzáférési jogunk, akkor megjelenítjük a hibaüzenetet a böngészõablakban, majd a continue utasítással továbblépünk a következõ adatbázisra. Ha ki tudjuk választani az adatbázist, a mûveletet a táblanevek kiírásával folytatjuk. Az adatbázis nevét átadjuk a mysql_list_tables() függvénynek, tároljuk az új eredményazonosítót, majd a mysql_fetch_row() függvénnyel kiolvassuk a táblák neveit. Minden táblán a következõ mûveletsort hajtjuk végre: kiírjuk a tábla nevét, majd összeállítunk egy SQL utasítást, amely az összes oszlopot lekérdezi az adott táblában. A mysql_query() függvénnyel végrehajtjuk a lekérdezést, majd az eredményazonosító alapján a mysql_num_fields() függvénnyel meghatározzuk a mezõk számát. A for ciklusban minden mezõn elvégezzük a következõ mûveletsort: beállítjuk az $x változót, hogy az aktuális mezõ sorszámát tartalmazza (ez kezdetben 0). Ezután a sorszám ismeretében meghívjuk az elõzõ részben tárgyalt összes ellenõrzõ függvényt, eredményüket pedig átlátható formában, táblázatba rendezve elküldjük a böngészõnek. Ezeket a mûveleteket minden elérhetõ adatbázison elvégezzük. A program egy áttekinthetõ szerkezeti vázlatot jelenít meg a böngészõablakban, amely az adott kapcsolaton keresztül elérhetõ összes adatbázist, adattáblát és mezõt tartalmazza. A 12.2. ábra a program kimenetét mutatja.

Adatbázisok kezelése MySQL 233 12.2. ábra Az összes elérhetõ adatbázis, tábla és mezõ listája Összefoglalás Ebben az órában a MySQL adatbáziskezelés alapjait tanultuk meg: az adatok tárolását és visszanyerését. 12 Megtanultuk, hogyan építsük fel a kapcsolatot a MySQL kiszolgálóval a mysql_connect() és mysql_pconnect() függvények segítségével. Az adatbázist a mysql_select_db() függvénnyel választottuk ki. Ha a kiválasztás nem sikerült, lekérdeztük a hibát a mysql_error() függvénnyel. SQL utasításokat adtunk ki a mysql_query() függvény segítségével és a függvény által visszaadott eredményazonosító segítségével elértük az adatokat vagy megtudtuk a módosított sorok számát. A PHP MySQL függvényeinek segítségével kiírattuk az elérhetõ adatbázisokat, táblákat és mezõket, és az egyes mezõkrõl is bõvebb információkat szereztünk.

234 12. óra Kérdések és válaszok Ez az óra szigorúan a MySQL-re vonatkozik. Hogyan ültethetjük át ezeket a fogalmakat más adatbázissal mûködõ rendszerekre? Az msql-kezelõ függvények például szinte teljesen megegyeznek a MySQL függvényekkel, de más SQL kiszolgálóknak is megvannak a saját PHP függvényeik. SQL utasításokat minden adatbáziskiszolgálónak küldhetünk. Ha szabványos ANSI SQL-lel dolgozunk, nem lesz különösebb problémánk az adatbáziskiszolgálók közötti átálláskor. Hogyan írhatunk olyan kódot, amelyet könnyû átültetni egy másik adatbázis kiszolgáló környezetbe? Gyakran jó ötlet az adatbázis-lekérdezõ függvényeket egy egyszerû osztályba vagy könyvtárba csoportosítani. Így ha fel kell készíteni a kódot egy másik adatbáziskezelõvel való együttmûködésre, a kódnak csak kis részét kell átírni. Mûhely A mûhelyben kvízkérdések találhatók, melyek segítenek megszilárdítani az órában szerzett tudást. A válaszokat az A függelékben helyeztük el. Kvíz 1. Hogyan kell csatlakozni a MySQL adatbáziskiszolgálóhoz? 2. Melyik függvény szolgál az adatbázis kiválasztására? 3. Melyik függvénnyel küldhetünk SQL utasítást a kiszolgálónak? 4. Mit csinál a mysql_insert_id() függvény? 5. Tegyük fel, hogy küldtünk egy SELECT lekérdezést a MySQL-nek. Nevezzünk meg három függvényt, amelyekkel hozzáférhetünk az eredményhez. 6. Tegyük fel, hogy küldtünk egy UPDATE lekérdezést a MySQL-nek. Melyik függvénnyel állapíthatjuk meg, hány sort érintett a módosítás? 7. Melyik függvényt kellene használnunk, ha az adatbáziskapcsolaton keresztül elérhetõ adatbázisok nevét szeretnénk megtudni? 8. Melyik függvénnyel kérdezhetjük le az adatbázisban található táblák neveit?

Adatbázisok kezelése MySQL 235 Feladatok 1. Hozzunk létre egy adattáblát három mezõvel: email (legfeljebb 70 karakter), uzenet (legfeljebb 250 karakter) és datum (a UNIX idõbélyegzõt tartalmazó egész szám). Tegyük lehetõvé a felhasználóknak, hogy feltöltsék az adatbázist. 2. Készítsünk programot, amely megjeleníti az 1. pontban elkészített tábla tartalmát. 12