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.
• 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.
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 );
ÚJDONSÁG
212 12. óra
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';
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
Adatbázisok kezelése – MySQL 213
12
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" );
214 12. óra
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:
2:
3:
5:
6:
7: 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
";
15: mysql_select_db( $adatbazis )
16: or die ( "Nem lehet megnyitni a $adatbázist: "
.mysql_error() );
17: print "Sikeresen kiválasztott adatbázis: \"
$adatbazis\"
";
18: mysql_close( $kapcsolat );
19: ?>
20:
21:
Adatbázisok kezelése – MySQL 215
12
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.
216 12. óra
12.2. program Új sor hozzáadása táblához
1:
2:
3:
4:
5:
6: 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:
23:
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.
Adatbázisok kezelése – MySQL 217
12
12.3.program A felhasználó által megadott adatok beszúrása a táblába
1:
2:
3:
4:
5:
6: 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
";
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();
218 12. óra
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 "method=\"POST\">\n";
51: print "A kívánt tartomány
\n";
52: print " ";
53: print "Email cím
\n";
54: print " ";
55: print "\n";
59: print "value=\"Elküld\">\n\n";
60: }
61: ?>
62:
63:
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.
Adatbázisok kezelése – MySQL 219
12
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
220 12. óra
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.
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:
2:
3:
4:
5:
6: Adatbázisok kezelése – MySQL 221
12
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
";
18: mysql_close( $kapcsolat );
19: ?>
20:
21:
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.
222 12. óra
12.5. program Tábla összes sorának és oszlopának megjelenítése
1:
2:
3:
4:
5:
6: 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
";
18: print "
| $mezo | \n";
27: mysql_close( $kapcsolat );
28: ?>
29:
30:
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.
Adatbázisok kezelése – MySQL 223
12
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 "
| ".$egy_sor["email"]." | ".$egy_sor["tartomany"]. å " | \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 "
| ".$egy_sor->email." | ".$egy_sor-> å tartomany." | \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é.
224 12. óra
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:
2:
3:
5:
6:
7: 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 );
Adatbázisok kezelése – MySQL 225
12
12.6. program (folytatás)
20: if ( ! $eredmeny )
21: die ("Nem sikerült a módosítás: "
.mysql_error());
22: print "
A tábla módosítva, ".
mysql_affected_rows() .
23: " sor változott
";
24: }
25: ?>
26:
43:
44:
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.
226 12. óra
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.7. program Adott kapcsolaton keresztül elérhetõ adatbázisok
1:
2:
3:
5:
6:
7: 8: $felhasznalo = "jozsi";
9: $jelszo = "bubosvocsok";
10: $kapcsolat = mysql_connect( "localhost",
$felhasznalo, $jelszo );
Adatbázisok kezelése – MySQL 227
12
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 )."
";
17: mysql_close( $kapcsolat );
18: ?>
19:
20:
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.
228 12. óra
12.1. ábra
Az elérhetõ adatbá-
zisok listája
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]."
\n";
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 ) . "
\n";
Adatbázisok kezelése – MySQL 229
12
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 ) . "
\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 ) . "
\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 ) . "
\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:
2:
3:
4:
5:
6: 7: $felhasznalo = "root";
8: $jelszo = "titkos";
9: $kapcsolat = mysql_connect( "localhost",
$felhasznalo, $jelszo );
230 12. óra
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 "".$adatbazisok[0]."\n";
16: if ( !@mysql_select_db( $adatbazisok[0],
$kapcsolat ) )
17: {
18: print "
- Nem lehet kiválasztani — " .
mysql_error() ."
19: continue;
20: }
21: $tablak = mysql_list_tables( $adatbazisok[0],
$kapcsolat );
22: print "\t
- \n";
23: while ( $tabla_sor = mysql_fetch_row( $tablak )
)
24: {
25: print "\t$tabla_sor[0]\n";
26: $eredmeny = mysql_query( "SELECT * from "
.$tabla_sor[0] );
27: $mezok_szama = mysql_num_fields( $eredmeny );
28: print "\t\t- \n";
29: for ( $x=0; $x<$mezok_szama; $x++ )
30: {
31: print "\t\t";
32: print mysql_field_type( $eredmeny, $x );
33: print " ";
34: print mysql_field_len( $eredmeny, $x );
35: print " ";
36: print mysql_field_name( $eredmeny, $x );
37: print " ";
38: print mysql_field_flags( $eredmeny, $x );
39: print "
\n";
40: }
41: print "\t\t
42: }
Adatbázisok kezelése – MySQL 231
12
12.8 program (folytatás)
43: print "\t - \n";
44: }
45: mysql_close( $kapcsolat );
46: ?>
47:
48:
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.
232 12. óra
Összefoglalás
Ebben az órában a MySQL adatbáziskezelés alapjait tanultuk meg: az adatok
tárolását és visszanyerését.
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.
Adatbázisok kezelése – MySQL 233
12
12.2. ábra
Az összes elérhetõ
adatbázis, tábla és
mezõ listája
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?
234 12. óra
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.