2. Az adatbázis-kezelés alapjai

2, Az adatbázis-kezelés alapjai

21

2. Az adatbázis-kezelés alapjai 2.1. Az adatbázis 2.1.1. Egy kis történelem Az élet számos területén találhatunk olyan gyűjteményeket, amelyek bizonyos szempontok szerint lettek összeválogatva. Eze ket a gyűjteményeket a szó klasszikus értelmében már adatbá zisnak tekinthetjük, hiszen a való világ egy jól meghatározott ré szét gyűjtöttük össze (absztrakció) és a gyűjtemény valamilyen rendszer szerint rendezve van. Ilyen gyűjtemény egy könyvtár, ahol nagymennyiségű könyvet találhatunk a művek fajtája, va lamint a szerzők neve szerint rendezve. De ilyen adatbázis egy íróasztal, ahol valamilyen sajátságos rendszer szerint hevernek az iratok. Ezek a papír alapú adatbázisok kezelés és feldolgozása nagy mennyiségű adat esetén már elég nehézkes és sok időt igénybevevő feladat volt, nem véletlenül a számítógépek széleskörű elterjedésekor ezen két funkció vált a legelterjedtebb műveletté. A számítógépek és az azokhoz kapcsolódó mágneses tárolók megjelenését követően hamarosan egy szűk kör számára elérhe tőek lettek az egyetemek és a kutatóintézetek által kifejlesztett különböző adatfeldolgozó rendszerek. Ezek a rendszerek a '60-as évek második feléig jobbára csak egyedi állományokat voltak ké pesek kezelni, amely azt eredményezte, hogy: ■ egy adott programmal csak adott adatállományt lehetet ke zelni, ■ egy adatállományt csak egy adott kezelőprogrammal lehet elérni, emiatt meg kell tanulni az adott kezelő nyelvet, * gyakorlatilag nincs adatvédelem, * az adatokhoz egyidőben történő hozzáférés nem megoldott. Ezen a problémák megoldására tett javaslatot 1971-ben a C o d a s y l- o n (Conference o f Data Systems Languages, v a g y is a z a d a tk e

22

Webes adatbázis-kezelés MySQL és PHP használatával

zelő rendszerek nyelveinek konferenciája) belüli DTBG (Data Base Task Group) csoport által készített jelentés, amelytől ténylegesen számítjuk az adatbázis-kezelés fogalmát. A jelentés javaslata sze rint a jövő adatbáziskezelő-rendszereinek a következő tulajdon ságokkal kell rendelkeznie: ■ egy adatbázis-kezelő szoftvernek több összetett logikai adatrendszereket kell tudni kezelnie egyszerre. * a redundancia feldolgozás gyorsítása érdekében megenge dett akkor, ha kézben lehet tartani. ■ konkurens hozzáférést kell biztosítania az adatbázis-kezelő rendszernek. * többféle elérési módot kell támogatnia egy időben. ■ támogasson többféle programozási nyelvet. (Lehessen prog ramozni) ■ támogassa az emberi logikát szemben a gépivel. ■ a jogosultság szempontjából lényeges, hogy egy adatmodell szemléletet valósítson meg - nézeteket lehessen kecelni. (Egy felhasználó csoport csak bizonyos adatokhoz férjen hozzá.) ■ visszaállítható legyen - ha sérül az adat (inkonzisztens ál lapotba kerül a rendszer), akkor azt lehessen felismerni, és helyreállítani. Adat-program függetlenség logikai és fizikai szinten. * logikai szinten: Ha az adatok szerkezete megváltozik, ne kelljen a program szerkezetét megváltoztatni. ■ fizikai szinten: Egy adott program tudja feldolgozni az adathalmazt függetlenül attól, hogy hol van fizikailag.

2.1.2. Relációs adatmodell A különféle adatbázis-kezelő rendszerek közül a XX. század végére a relációs adatbázis-rendszerek szinte egyeduralkodóvá váltak a világban, szinte teljesen kiszorítva a piacról a különböző hálós- és hierarchikus adatmodelleken alapuló adatbázisrend szereket. A legelterjedtebb relációs adatbázis-kezelő rendszerek az Oracle, a MySQL, a SYSBAS, INGRES, MS SQL, INFORMIX. A relációs adatbázis-kezelés alapjait még 1971-ben a Codd ál tal megalkotott relációs adatmodell elméletét alapozta meg, amelynek hatására létrejöttek a relációs adatbáziskezelő rendszerek. A modell pontos leírása bonyolult matematikai mód szereket történt meg, melynek részletei megtalálhatóak az adat bázis-kezeléssel mélyebben foglalkozó művekben. Az adatbázis-kezelésben a ’70-es évek végétől élesen szétvált a logikai és a fizikai modell, melynek következtében számítógép rendszer független módon lehet adatbázis sémákat készíteni. A

2. Az adatbázis-kezelés alapjai______________________________________ 23

szétválás következtében természetesen a relációs adatbázis kezelésben is elkülönült ez a két modellezési szint. Logikai szinten a relációk táblákban jelennek meg. Egy adat bázison belül a tábláknak egyedi nevük van. A táblák oszlopait attribútumoknak (oszlopoknak) nevezzük. Az attribútumok sor rendje kötött. Az attribútumok értékeit egy úgynevezett attribú tum-halmazból veheti fel és értékeinek eleminek kell lenni. A tábla soraiban helyezkednek el a rekordok. A modell nem engedi meg, hogy két rekord megegyezzen! Egy rekord adott attribútu mának értékét a mező értékének nevezzük. A tábla sorait tetsző legesen megcserélhetjük, a sorok száma elméletileg nem kötött, de a számítógépes háttértároló nagysága, valamint az adatbáziskezelő-rendszer fajtája azért határt szabhat. Az adatbázis táblák ból, valamint a táblák közötti kapcsolatból épül fel. A kapcsolat ez egyik tábla elődleges kulcsa és a másik tábla külső kulcsa között jön lére, mégpedig azzal a megszorítással, hogy a külső kulcs valamennyi értékének szerepelnie kell az elsődleges kul csok között, vagy NULL értékű kell lennie. A külső kulcs tényle ges használata MySQL 5-ös verziójában lesz elérhető valamennyi táblatípus esetében, jelenleg azonban csak az InnoDB táblatípus kezeli, bár a többi táblatípusnál is megadható csak az adatbáziskezelő-rendszer nem foglalkozik vele. A rekordok (sorok) egyediségét az elsődleges kulcs biztosítja, mely akár állhat egy attribútumból (pl.: sorszám) is, vagy állhat több attribútumból (pl.: név, anyja neve, születési idő) is, a lé nyeg az, hogy legyen. Az elsődleges kulcs nem vehet fel NULL ér téket sem. Fizikai szinten az adatbázis valamilyen állományszerkezetben van tárolva, melynek kezelése az operációs rendszer feladata.

2.1.3. Az adatbázis logikai tervezése A számítógépen tárolni kívánt adatbázisunk elkészítésének ez az első és talán a legfontosabb része. Fontosságát az adja, hogy az elkövetkezendőkben megtervezett adatbázisunkhoz kell majd megírni a különböző programokat, ebből az adatbázisból kell majd kinyernünk értékes információkat és nem utolsó sorban ezt az adatbázist kell karbantartanunk. A címben lévő „logikai tervezés” azt jelenti, hogy ezen művelet végrehajtásához nem kell számítógép és az elkészült adatbázis terv bármilyen relációs adatbázis-kezelő program segítségével megvalósítható, függetlenül attól, hogy milyen operációs rend szert használunk. Ennél fogva a tervezés során nem kell odafi

24


gyelnünk a különböző Számítógép-rendszerek által megkövetelt szabályok betartására. A logikai tervezés fő feladata a redundancia, azaz egy adat több helyen történő tárolásának minimális szintre csökkentése. A redundancia megszüntetése elsősorban a karbantartási műve letek során nyújt segítséget és feltétele annak, hogy az adatbázi sunk ne kerüljön inkonzisztens állapotba, melynek eredménye ként egy lekérdezés során hamis eredményeket kaphatunk. A redundancia megszüntetésének módja a normalizálás. A norma lizálás során célszerű azt a harmadik normálforma eléréséig foly tatni. A normalizálás folyamatát egy példán keresztül fogjuk meg vizsgálni. A feladat egy számlázási rendszer kialakítása lesz. A számla elkészítéshez szükséges adatok a következők: ■ rendelés száma ■ dátum ■ vevőnév —7 ■ vevőkód ■ vevőcím ■ számlaszám ■ cikkszám ■ megnevezés ■ mennyiségi egység ■ egységár ■ mennyiség ■ határidő A szükséges adatokat úgy célszerű összeállítani, hogy szerepeljen benne az összes olyan adat, amely a kimenetnél fontos lehet, vi szont ne szerepeljenek benne olyan adatok, amelyek valamely attribútumból származtathatók (pl.: az egységárból és a mennyi ségből kiszámolható a számlán szereplő termék ára, ezért nem kell az adatbázisban tárolnunk azt. Fontos, hogy a séma kialakí tásánál a szemünk előtt a minél egyszerűbb és hatékonyabb le kérdezés lebegjen. Látszólag ez egy nagyon egyszerű feladatnak tűnik, hiszen egy tábla létrehozásával megoldható lenne a probléma, csakhogy a relációs adatbázis elméletével ellentétes, hogy egy attribútum érték ne elemi legyen, márpedig ha egy számlán több cikk is sze repelhet, vagy egy cikk több rendelésnek a része lehet, akkor ez a feltétel már nem teljesül.

25

2. Az adatbázis-kezelés alapjai

rendelés száma dátum vevőnév vevőkód vevőcím számlaszám határidő cikkszám megnevezés mennyiségi egység egységár mennyiség Megjegyzés: Az aláhúzás a tábla elsődleges kulcsát jelöli, a szürke háttérben a nagybetűs szöveg a tábla nevét jelzi. Ha egy táblában az attribútumok értékei valamennyi esetben elemiek, akkor azt mondjuk, hogy az adatbázis séma IN F (első normálformájú). Ebben az esetben a cikkszám, a megnevezés, a mennyiségi egység, az egységár, a mennyiség attribútumok helyén több érték is szerepelhet, abban az esetben, ha több tétel kerülne megvásár lásra. E probléma megoldása nagyon egyszerű, egy újabb táblázattal kell bővítenünk az adatbázis sémánkat, hogy valamennyi érték egyedi legyen. Ennek legegyszerűbb módja, hogy az ismétlődő attribútumokat egy külön táblába tesszük. <

RENDELÉS rendelés száma Dátum Vevőnév Vevőkód Vevőcím Számlaszám Határidő

TÉTEL rendelés szám cikkszám megnevezés mennyiségi egység egységár mennyiség

Látható, hogy a megvalósítás során az eredeti táblánkból két tábla keletkezett, mégpedig úgy, hogy az ismétlődő attribútum értékekből külön táblát készítettünk. Az újonnan készített táb lánkban a rendelés szám, valamint a cikkszám attribútumok (amelyek a TÉTEL tábla összetett elsődleges kulcsai) együtt biz tosítják, hogy az eredeti táblában lévő nem elemi attribútumok visszaállíthatóak legyenek adatvesztés nélkül.

26


Abban az esetben, ha az elsődleges kulcs egyszerű, akkor az adatbázis séma 2 NF-ben van, ha nem nekünk kell megszüntetni a részleges függőségeket. Részleges függőség akkor áll fenn, ha az összetett kulcs egyik tagjától függ valamelyik leíró attribútum. Példánkban, a TÉTEL táblában a cikkszám attribútumtól függ a megnevezés, a mennyiségi egység és az egységár attribútumok is. A részleges függőséget, úgy tudjuk megszüntetni, hogy meg szüntetjük a táblák egymásba ágyazását és ezzel új táblákat ho zunk létre. Természetesen az adatbázis sémánknak ebben az esetben is 1 NF-ben is kell lennie. rendelés száma dátum vevőnév vevőkód vevőcím számlaszám határidő

TÉTEL rendelés szám cikkszám mennyiség

CIKK cikkszám megnevezés mennyiségi egység egységár

A művelet során létrehoztunk egy új táblát, mégpedig azért, hogy a TÉTEL táblában a cikkszám elsődleges kulcs rész által okozott részleges függést feloldjuk, és ennek a legegyszerűbb módja, hogy a függő attribútumokat külön táblába helyeztük és a tábla elsődleges kulcsának a TÉTEL tábla cikkszám attribútumát adtuk meg. A következő lépés, hogy a 2 NF-ben lévő sémánkat 3 NF-ra bontjuk, azaz megszüntetjük benne a tranzitív függőséget. A tranzitív függőség akkor áll fenn, ha az egyik leíró attribú tumtól függ egy másik leíró attribútum. Fia egy séma 2 NF-ben van és nincs benne tranzitív függőség, akkor 3 NF-ben is van. A RENDELÉS táblában a vevőkód meghatározza a vevőneve, a vevő címe, valamint a számlaszám attribútumot. E szintén új táblák létrehozásával oldható meg, mégpedig, úgy hogy az egymástól függő attribútumokat kiemeljük a táblából és tetszőleges, de egyedi attribútumát kijelöljük elsődleges kulcsnak. RENDELES-2 rendelés száma dátum vevőkód határidő

TETEL rendelés szám cikkszám mennyiség

CIKK cikkszám megnevezés mennyiségi egység egységár

2. Az adatbázis-kezelés alapjai_________

27

VEVŐ vevőkód vevőnév vevőcím. számlaszám Mivel a RENDELÉS táblában a vevőkód meghatározta a többi vevő adataival kapcsolatos attribútumot, ezért azokat kiemeltük egy külön táblába és a vevőkód attribútumot választottuk elsőd leges kulcsnak. Természetesen bármelyik más attribútumot is választhattuk volna elsődleges kulcsnak, amely egyértelműen azonosítja az adott rekordot (pl.: számlaszám, ha nincs két ugyanolyan számlaszámú vevő vagy a vevőnév, ha nincs két ugyanolyan nevű cég), de mi a legegyszerűbb megoldást válasz tottuk egy rövid numerikus értéket (erre a fogalomra még később visszatérünk). A művelettel a RENDELÉS-2 táblában lévő vevő kód külső kulcs lett. Nagyon fontos dolog, hogy a relációs adatmodell nem kezeli az úgynevezett N:M kapcsolatot, amelyet az adatbázis séma 3 NF-ba hozásával a normalizálás automatikusan megszüntet. Az N:M kapcsolat a gyakorlatban azt jelenti, hogy egy rendelésnél több cikket is rendelhetünk és egy cikk több rendelésben is szerepel het a számláinkon. Az N:M típusú kapcsolat a normalizálás sorásí átalakul 2 darab 1:N típusú kapcsolattá.

A relációs adatbázis-kezelők megkövetelik INF sémát, nem normalizált táblázatokat nem tudnak kezelni. A normalizálás tovább folytatható, hiszen léteznek 4 NF, 5 NF... normálformák is, de a gyakorlatban magasabb szintű nor málformákkal már nem találkozhatunk.

2.1.4. Az adatbázis fizikai tervezése Ez az a pont, ahol elő vehetjük a számítógépet, és megtekint hetjük az adatbázis-kezelő rendszerünk dokumentációját, ugyan is a fizikai tervezés nem jelent mást, mint meghatározni, hogy az egyes táblákban szereplő attribútumok (oszlopok vagy mezők) milyen tulajdonsággal rendelkezzenek. Az előző példán végigha ladva nézzük meg milyen lehetőségeink vannak:

28___________________Webes adatbázis-kezelés MySQL és PHP használatával Attribútum megnevezése rendelés száma dátum vevőkód határidő

Attribútum Attribútum típusa hossza RENDELÉS-2 numerikus 6 számjegy dátum numerikus 5 számjegy dátum

vevőkód vevőnév vevőcím számlaszám

numerikus szöveg szöveg numerikus

':: '- - ' .; új rendelés szám numerikus

VEVŐ 5 számjegy 30 karakter 50 karakter 24 számjegy TÉTEL 6 számjegy

cikkszám mennyiség

numerikus numerikus

8 számjegy 4 számjegy

cikkszám megnevezés mennyiségi egység egységár

numerikus szöveg szöveg

CIKK_________ 8 számjegy 15 karakter 5 karakter

numerikus

6 számjegy

Megjegyzés elsődleges kulcs külső kulcs

elsődleges kulcs külső kulcs

összetett elsődleges kulcs

______________ ' j ______ elsődleges kulcs

Az attribútum típusának meghatározása során elsősorban a tapasztalatunkra hagyatkozhatunk. Azonban van néhány íratlan szabály, amit érdemes betartanunk: * az elsődleges kulcsokat célszerű numerikus típusúra ter vezni, mivel a legtöbb adatbázis-kezelő rendszer ismeri az automatikus értékadást; ■ ha egy értékkel számítási műveleteket akarunk végezni, akkor annak típusa mindig legyen numerikus; * a külső kulcsoknak, olyan típusúnak és méretűnek kell lenniük, mint a hozzájuk tartozó elsődleges kulcsoknak; ■ mindig akkora értéket válasszunk az attribútum nagysá gának, hogy később már ne kelljen megnövelni, az sem baj, ha egy kicsit túlméretezzük az értékeinket (ha van elég tárolókapacitásunk); ■ ha dátum értéket akarunk tárolni, a későbbi művelet vég rehajtások miatt célszerű dátum típust megadni; ■ olyan attribútumoknál, ahol az érték viszonylag állandó (pl.:egy termék esetében az ÁFALkulcs) célszerű azt alapér telmezettként megadni;

40

Webes adatbázis-kezelés-MySQL és PHP használatával

Itt hét sor lett módosítva. Fontos, hogy a tizedesvessző az an gol terminusnak megfelelően pont(.). A két példánál jól láthatjuk, hogy a módosított tábla valam ennyi sora megváltozott, annak következtében, hogy nem adtunk meg szűkítő feltételt. Ha azt szeretnénk elérni, hogy a táblázat csak bizonyos sorai kerüljenek módosításra, akkor szükségünk van a WHERE záradék használatára. A w h e r e pontos használatával a SELECT utasításnál fogunk megismerkedni. Addig is csökkent sük az olaj árát: Mező értékének változatása feltétel megadásával mysql> UPDATE cikk SET egysegar=egysegar*05 WHERE ->megnevezes='olaj'; Query OK, 1 rows affected (0.06 sec) Rows matched: 1 Changed: 1 Warnings: 0

A tábla adatainak törlésére a DELETE FROM táblanév WHERE feltétel parancs szolgál. Ha elhagyjuk a WHERE záradékot, akkor a tábla valamennyi sorát törölhetjük. Nagyon veszélyes mutatvány!!! A következő parancs segítségével lehet egy sort törölni a táblából (az 51-es cikkszámú rekordot töröljük): ) Egy rekord törlése mysql> DELETE FROM cikk WHERE cikk_id=51; Query OK, 1 row affected (0.03 sec)

2.2.4. Lekérdezések Az utolsó és egyben a leggyakrabban használt és emiatt talán a legbonyolultabb utasítás a SELECT. Az utasítás az adatbázisban lévő adataink valamilyen feltétel szerinti lekérdezésére szolgál. Segítségével lehetőségünk van az adathalmazunkból nagyon sok féle szempont szerint kiválasztani néhányat és azokkal szinte bármilyen műveletet végre is tudunk hajtani. A SELECT utasítás egyszerűsített szintaktikája a következő: SELECT attribútuml [, attribútum2...] FROM táblanévl [, táblanév2,...] [WHERE feltétel] ; Mielőtt még nagyon megörülnénk, hogy ennyi, meg kell je gyezni, hogy ez tényleg csak a kezdet, de a fejezet végére megta nuljuk, hogyan lehet bármilyen bonyolult lekérdezést megírni.


41

Kezdjük a legelején, a cikk tábla valamennyi sorának lekérde zésére a következő két utasítás egyaránt használható, a * karak ter valamennyi attribútumot helyettesíti, ha nem szeretnénk az összes attribútumot megjeleníteni, akkor csak a megjeleníteni kívánt attribútumokat kell a SELECT után í'eltüntetni: SELECT használata mysql> SELECT * FROM cikk; mysql> SELECT cikk_id, megnevezés, mennyisegi_egyseg, egységár ->FROM cikk;

bármelyik változatot lefuttatva, a következő eredményt kapjuk (érdemes odafigyelni a végrehajtás sebességére): SELECT használatának eredménye +--------------+---------------- +-----------------------+--------------+ | cikk_id

|megnevezés

| mennyisegi_egyseg

| egységár |

+------------ +-------------- +---------------------+------------ + 1 2 20 21 40 50

csavar csavarkulcs olaj ecset gitt toll

db db 1 db kg db

12500 1000 22500 312 249 269

+----------- +----------------- +------------------------- +------------- + 6 rows in set (0.00 sec)

A MySQL lehetőséget biztosít arra, hogy a hosszú attribútum nevek helyett rövidebbet használjunk, az előbbi példánál maradva: SELECT használata oszlopnév megadásával mysql> SELECT cikk_id AS cikkszam, megnevezés, -> mennyisegi_egyseg AS me, egységár FROM cikk; — — +---------cikkszam 1 megnevezés me | egységár 1 2 20 21 40 50

1 1 1 1 1

csavar csavarkulcs olaj ecset gitt toll

db db 1 db db db

12500 1000 22500 312 249 269

H----------------------------------- 1--------------------------------------------- 1---------------------- 1-----------------------------------h

6 rows in set (0.00 sec)

42


A táblázat fejsorában láthatjuk, hogy az új név jelent meg, melynek hatására érthetőbbé és áttekinthetőbbé válhat a lekér dezésünk, hiszen nem kódokat, hanem „értelmes” szövegeket adhatunk meg. A lekérdezésünk további szépítésére ad lehetőséget az ORDER BY záradék, melynek feladata a megadott attribútum(ok) szerint a lekérdezésünk sorba rendezése. A záradék utáni attribútum ne vek szerint rendezi a lekérdezést a MySQL, ami jelen esetünkben azt jelentené, hogy először a megnevezés szerint, majd ha két ugyanolyan megnevezést talál akkor az egységár szerint. Az attri bútum után megadott d e s c kiegészítéssel a rendezés megfordít ható: SELECT használata sorba rendezéssel mysql> SELECT cikk_id AS cikkszam, megnevezés/ -> mennyisegi_egyseg AS me, egységár FROM cikk ORDER BY -> megnevezés, egységár;

+--------------- +--------------- +-------- +-----------+ | cikkszam

|megnevezés

|me

| egységár |

+--------------+-------------- +--------+----------+ 1 2 21 40 20 50

csavar csavarkulcs ecset gitt olaj toll

db db db kg 1 db

12500 1000 312 249 22500 269

+------------- +----------------- +--------+------------- + 6 rows in set (0.00 sec)

Az eddigi összes példa az adott tábla valamennyi sorát meg mutatta számunkra, ami az esetek többségében nem túl szeren csés, főleg több ezer rekordot tartalmazó táblákban. A lekérdezé sünk szűkítéséhez nyújt segítséget a már korábban említett WHERE záradék. A WHERE után gyakorlatilag bármilyen logikai öszszehasonlító művelet megadható (egyenlőség, kisebb, nagyobb érték, logikai művelet, mintaillesztés, stb.). Lekérdezéseinkhez a cikk táblát fogjuk használni végigpróbál va, azokat a lehetőségeket, amelyet a MySQL biztosít számunkra, szükség esetén magyarázattal: 2.2.4.1. Összehasonlító operátorok használata Az összehasonlít operátorok megegyeznek a matematika órán tanult operátorokkal, így ezek használata nem okozhat sok gon dot. A MySQL által használt operátorok: <, >, =, !=, <>, <=, >=.


43 Összehasonlító operátorok használata

A csavar adatainak lekérdezése: SELECT * FROM cikk WHERE megnevezes='csavar'; A 2000 Ft-nál drágább termékek lekérdezése: SELECT * FROM cikk WHERE egységár>2000; Azon termékek lekérdezése, melyeknek a mennyiségi egysége nem 'db', a '!=' helyett használható '<>' is: SELECT * FROM cikk WHERE mennyisegi_egyseg !='db';

2.2.4.2. Logikai operátorok használata A logikai operátorok egy, kettő vagy több feltétel összekapcso lására szolgálnak. A MySQL-ben a leggyakrabban használt há rom logikai operátor az and , az OR és a NOT. Az and esetében az összetett feltétel akkor igaz, ha minkét oldala igaz, OR esetében akkor igaz, ha valamelyik oldala igaz, NOT esetében akkor igaz, ha a feltétel hamis. A lekérdezés során azok a rekordok fognak megjelenni, ahol a vizsgált mező értéke megfelel a feltételeknek, azaz igaz értéket ad vissza. Logikai operátorok használata A 800 Ft-nál drágább és 5000 Ft-nál olcsóbb termékek lekérde zése : SELECT * FROM cikk WHWRW egységár > 800 AND egységár < 5000; A termék mennyiségi egysége vagy 'kg' vagy '1': SELECT * FROM cikk WHERE mennyisegi_egyseg ='kg' OR mennyisegi_egyseg ='1'; A termék mennyiségi egysége nem 'db': SELECT * FROM cikk WHERE NOT (mennyisegi_egyseg ='db');

A logikai operátorok használatának sorrendje zárójelek segít ségével módosítható, mindig a belső zárójelen belüli művelet ér tékelődik ki először, majd az utána következő, egészen addig, míg el nem fogynak a zárójelek. A 2000 Ft-nál drágább kg vagy 1 mennyiségi egységű termékek lekérdezésének módja: Zárójelek használata a kiértékelés során SELECT * FROM cikk WHERE (mennyisegi_egyseg ='kg' OR mennyisegi_egyseg ='l') AND egységár >2000;

44


Most megcseréltük a zárójelet és a lekérdezés a ’kg’ mennyisé gi egységű, valamint a 2000 Ft-nál drágább T mennyiségi egysé gű cikket listázza ki: Zárójelek használata a kiértékelés során SELECT * FROM cikk WHERE mennyisegi_egyseg ='kg' OR mennyis eg i_egys eg AND egységár >2000);

2.2.4.3. NULL érték használata Korábban azt mondtuk, hogy azon mezők értéke, amelyeknek nem adtunk meg értéket NULL. így a lekérdezések során sem tud juk úgy használni, mint az elvárható lenne. Egy mező NULL érté kének vizsgálatára az is null vagy az is not null záradék használ ható. Az egységár attribútumban a nem NULL értékű (kitöltött) re kordokat jeleníti meg: NULL érték lekérdezése SELECT * FROM cikk WHERE egységár IS NOT NULL;

2.2.4.4. Tagság vizsgálata Sokszor szükséges annak vizsgálata, hogy egy mező értéke be leesik-e egy általunk megadott tartományba. Erre a MySQL több lehetőséget is kínál, bár ezek kiválasztását mindig a feladat szab ja meg. Ha egy értéktartományba szeretnénk megállapítani, hogy a mező értéke benne van-e, akkor a BETWEEN operátort használ juk, ha arra vagyunk kíváncsiak, hogy az általunk megadott fel sorolásban benne van-e az adott érték akkor az IN operátor használata szükséges, ellenkező esetben a NOT IN. Mindhárom operátor használata kiváltható a logikai operátorok alkalmazásá val.


45

2.2.4.5. Mintaillesztés A szabvány ANSI SQL által biztosított eljárás, hogy a lekérde zéseinket, akkor is végre tudjuk hajtani, ha nem ismerjük az adott mező értékét. Természetesen ebben az esetben is rendel keznünk kell némi információval, ami lehet egy szöveg eleje, vé ge, vagy akár a belsejéből egy vagy több darab. A MySQL-ben a mintaillesztés megvalósítására a LIKE záradék szolgál. A követ kező példákban végigmegyünk a leggyakrabban használt úgyne vezett reguláris kifejezéseken. Ha ismerjük a feltételünkben szereplő szöveg elejét akkor a ’%’ operátorral tudjuk leggyorsabban megoldani a lekérdezésünket, látható, hogy a parancs hatására csak a ’csa’ karakterekkel kez dődő rekordok íródtak ki: Like használata mysql> SELECT * FROM cikk WHERE megnevezés LIKE 'csa%1; id | megnevezés 1 2

csavar csavarkulcs

mennyi segi_egys eg db db

egységár | 12500 1000

+---------- +---------------- H-----------------------+-------------h 2 rows in set (0.00 sec)

A ’%’ operátor korlátlan számú karakter helyettesítésére szol gál ellentétben a V karakterrel, amely csak egy karakter helyet tesítését végzi. Az öt betűs ’csa’-val kezdődő mezőket meglététének vizsgálatá ra a jó megoldás (3 pont=3 tetszőleges karakter): Like használata mysql> SELECT * FROM cikk WHERE megnevezés LIKE ’csa. . . ’;

A ’[]’ zárójelek közt bármilyen karaktert [Cc], vagy karaktertar tományt [a-zA-Z] beírhatunk de csak akkor fog az adott feltétel nek megfelelni, ha az adott pozícióban a [] közt lévő karakter van: Like használata mysql> SELECT * FROM cikk WHERE megnevezés LIKE 1cs[aeo]var1;

ebben az esetben csak a csavar, csevar, csővár fog a feltételnek megfelelni. Annak vizsgálatára, hogy egy szöveg belsejében tetszőleges he lyen lévő karaktersorozat megfelel-e a feltételnek a LIKE helyett a REGEXP kifejezés használható. Ahhoz, hogy le tudjuk kérdezni

46___________________Webes adatbázis-kezelés MySQL és PHP használatával

azokat a rekordokat, melyek megnevezésében szerepel a ’cs’ betű a következő utasítást kell begépelnünk: A REGEXP használata mysql> SELECT * FROM cikk WHERE megnevezés REGEXP 'c s '; H------------------------------- H------------------------------------------1----------------------------------------------------- 1-----------------------------------f-

| cikk_id

|megnevezés

|mennyisegi_egyseg | egységár

|

+------------- +----------------- +------------------------ +-------------- + csavar csavarkulcs ecset

1 2 21

db db db

12500 1000 312

+----------- +----------------- +------------------------- +------------- + 3 rows in set (0.01 sec)

2.2.4.6. Csoportosítások A szabványos SQL lehetőséget biztosít arra, hogy adatainkat csoportosítsuk, illetve egy adott csoporttal valamilyen egyszerű műveletet végezzünk. Ilyen esetek lehetnek például, ha kíváncsi ak vagyunk, mely városokban vannak ügyfeleink, vagy melyik termékből átlag mennyit adtunk el, mekkora áron stb. Lássuk ezen példák megoldását: Arra a kérdésre, hogy mely városban vannak ügyfeleink egy „hagyományos” -SELECT vevocim FROM vevő;- lekérdezéssel megoldható lenne csak ebben az esetben a táblánk valamennyi rekordját kiírja a lekérdezés, ez pedig egy több ezer soros adatbá zisban nem nyújt segítséget, helyette használjuk a GROUP BY zá radékot, amely a csoportosítást végzi el helyettünk. A lekérdezés megfelelő (nem hamis) eredményének kiíratásához fontos, hogy a GROUP BY záradék után szereplő attribútum a SELECT utasítás után szerepeljen és csak olyan attribútumokkal, amelyek számí tott értékek (AVG, SUM, stb.): A GROUP BY paraméter használata mysql> SELECT vevocim FROM vevő GROUP BY vevocim;

+------------- + | vevocim

i

+------------ h Szeged Budapest j Debrecen j

+------------+ 3 rows in set (0.09 sec)

Természetesen itt is van lehetőségünk némi szűkítésre a HAVING paraméterrel. A ’b’ betűvel kezdődő városneveket írathat juk ki a következő paranccsal:

47


A having használata mysql> SELECT vevocim FROM vevő GROP BY vevocim HAVING -> vevocim LIKE 'b%';

+----------- + | vevocim

j

-(------------ +

| Budapest |

+----------- +

1 row in set (0.00 sec)

A csoportosítás elején említettük, hogy néhány alapvető műve let elvégzésére is van lehetőségünk. Ezek a műveletek az átlago lás (a v g , az összesítés (SUM), a darabszám (COUNT), minimális ér ték (m i n ), maximális érték (m a x ) meghatározása. A példákon ke resztül megnézhetjük, hogy ez a néhány művelet mennyire leegy szerűsítheti a lekérdezéseinket. íme néhány, a gyakorlatban is használható példa: Termékkódonként mennyi az átlagos megrendelés: Az AVGQ függvény használata mysql> SELECT cikkszam, AVG(mennyiség) FROM tetei GROUP BY -> cikkszam; -I----------- H-----------------+ | cikkszam |avg(mennyiség) |

H ------------- 1 --------------------+ 1 20 21 40 50

10.0000 5.0000 15.0000 13.3333 4.0000

+----------- +------------------- + 5 rows in set (0.08 sec)

Egy adott cikkből mennyi volt a maximális megrendelés: A MAX() függvény használata mysql> SELECT cikkszam, M A X (mennyiség) FROM tetei GROUP BY -> cikkszam;

+----------- +------------------- +

| cikkszam | m a x (mennyiség) | +--------- +--------------- + 1 20 21 40 50

10 5 15 20 4

+----------- +------------------- + 5 rows in set (0.00 sec)

48__________________ Webes adatbázis-kezelés MySQL és PHP használatával Egy adott termékből mennyi volt a minimális megrendelés: A MINQ függvény használata mysql> SELECT cikkszam, MIN(mennyiseg) FROM tetei GROUP BY -> cikkszam;

+-------------+--------------------- + [ cikkszam | min(mennyiség) | +---------- +---------------- + 1 10 20 5 21 15 40 8 50 4

H ------------- 1 ------------------- - + 5 rows in set (0.00 sec)

A COUNT0 függvény segítségével kiírattathatjuk melyik rende lés során, mennyi tételt rendeltünk: A COUNTQ függvény használata mysql> SELECT rendeles_id, COUNT(rendeles_id) FROM tetei GROUP -> BY rendeles_id;

+--------------- +------------------------ + | rendeles_id | count(rendeles_id)

'

3 rows in set (0.00 sec)

És végül egy bonyolultnak tűnő, de nagyon hasznos példa, a számítás és a szűrés használata egy utasításban. Melyek azok a rendelések, ahol a tételszám kevesebb, mint há rom: A COUNTQ függvény használata szűréssel mysql> SELECT rendeles_id, COUNT(rendeles_id) FROM tetei GROUP -> BY rendeles_id HAVING COUNT(rendeles_id) <3;

+--------------- +------------------------- + | rendeles_id | count(rendeles_id)

|

+-----------------+--------------------------- + 2 2 | 3

1 |

+--------------- +------------------------- + 2 rows

in set (0.02

sec)

49


2.2.4.7. Függvények A MySQL hasonlóan bármely programozási nyelvhez sok be épített függvénnyel rendelkezik, ezek a függvények egy értéket adnak vissza, attól függően, hogy milyen függvénynevet, illetve paramétereket adunk meg. A leggyakrabban használt függvények a matematikai, a szöveg, valamint a dátum és a logikai függvé nyek. A függvények elhelyezkedhetnek a SELECT utasítás után, vagy a w h e r e ,illetve a HAVING BY után a feltételekben. A leggyakrabban használt függvények leírását és használatát a következő táblázat tartalmazza: Függvény neve, paraméterei

ascii(’c’) char(77,121,83,8 1,76) concat(’szövegl’, ’szöveg2’...)

instr(miben, mit)

length(szöveg)

leftf szöveg’,szám)

lowerf szöveg’) ltrim(’szöveg') repeat(’szöveg’, szám) rightfszöveg’, szám)

rtrim(’szöveg’)

Példa (select után megadva) Szöveg függvények

Leírása

A ’c’ karakter ASCII kódját adja vissza numerikus értékek átalakítása az ascii kódtábla szerint karaktersorozatok összefüzésére szol gál megadja, hogy a keresendő szöveg hol kezdődik az első paraméterben visszaadja a szöveg hosszát a szöveg elejéből a számnak megfelelő darab karaktert ad vissza a szöveget kisbe tűsre konvertálja eltávolítja a szöveg elejéből a szóköz karaktereket a szöveget számszor leírja egymás mellé a szöveg végétől a számnak megfelelő darab karaktert ad vissza eltávolítja a szöveg végéből a szóköz karaktereket

A példa ered ménye

ascii(’b’)

98, a ’b’ ka rakter ascii kódja

char(77,121,83,81, 76)

MySQL

concat(’My’, ’S’.’QLj

MySQL

instrfbarangolásYg ol’)

6

length (’darabj

5

left(’MySQL’,3)

MyS

lower(’MySQL’)

mysql

ltrimf

MySQL

MySQLj

repeat(’MySQL’,2)

MySQLMySQL

right(’MySQL’,3)

SQL

rtrim(’MySQL

j

MySQL

50___________________Webes adatbázis-kezelés MySQL és PHP használatával

strcmpfszöveg 1’, ’szöveg2’)

upper(’szöveg’)

+,

*, /, div

abs(szám) crc32 (’szöveg’) mod(szám, szám) piü power(száml, szám2) rand() round (szám) sqrt(szám)

curdateO curtimeO date(’dátum’)

datediff(’dátum 1’ , ’dátum2’)

visszatérési értéke 0, ha a két szöveg azonos, -1, ha az strcmp(’MySQL’,’My első előbbre van az SQL’) ábécében, mint a második, különben 1 a szöveget nagybe upper(’MySQL’) tűsre konvertál) a Aritmetikai függvények alapvető aritmetikai műveletek, vala mint az osztás 5 div 2 egész részének meghatározására szolgáló div Matematikai függvények a szám abszolút abs(-2) értékét adja vissza Egy szöveg ere kód crc32(’MySQL’) lát adja vissza maradványértéket mod (355,10) ad vissza osztásnál a pi értékét adja vissza a számi szám2-dik hatványát adja power (2,2) vissza véletlenszerű szá mot ad vissza 0 és egy között visszaadja a számot round (3,14) egészre kerekítve megadja a szám sqrt(4) gyökét Dátum és idő függvények Aktuális dátum curdateO lekérdezése aktuális idő lekér curtimeO dezése egy teljes dátum idő date(’2005-05-20 szöegből visszaadja 12:4:22’) a dátum értékét megadja a két dá tumérték közötti date(’2005-05-20’távolságot napok ’2005-05-25’) ban (csak a 4.1.1 verziótól)

0

MYSQL

2

2 3259397556 5 3.141593

4 0.2358746951 254 3 2

2005-05-20 12:03:18 2005-05-20

5


date_add(’dátum’ , interval érték értékfajta)

date_format(’dát um’, formátum)

dayname(’dátum’ ) monthnamefdát umj now() time(’dátum’)

timedefff dátum 1 , dátum2)

a megadott dátum hoz adja hozzá a megadott fajta érté ket. A leggyakrab ban használt érték fajták: year, month, day, hour, minute, second) a dátum és az idő megjelenítési for máját lehet beállí tani) a formátumok paramétereit a kö vetkező táblázat tartalmazza (csak a 4.1.1 verzió tól) megadja a dátum ban lévő nap angol nevét megadja a hónap nevér angolul megadja az aktuális időt a dátumból megad ja az időt a két dátumok kö zött kiszámítja az időeltérést (csak a 4.1.1 verziótól)

51

date_add(’2005-0512’, interval 2 day)

2005-05-14

dateformat(’200505-23’, '%Y. %M %d. %Wj;

2005. May 23. Monday

dayname(’2005-0523)

Monday

monthname(’200505-23)

May

now()

2005-May-21 12:24:38

time(’2005-05-23 12:24:38’) timedeff(2005-0521 23:59:59.000001’, -> '2005-05-20 01:01:01.000002');

12:24:38

46:58:57.9999 99

A dátum és idő függvények formázott kiíratásához szükséges kapcsolók: formátum %a %W %b %M %H °/oh %j °/ou %Y %y

leírás a nap neve röviden angolul (Sun...Sat) a nap neve angolul (Sunday...Saturdy a hónap neve röviden angolul (Jan...Dec) a hónap neve angolul (January...December) az órák kiírása 0-24-es formátumban az órák kiírása 0-12-es formátumban a nap száma az évben a hét száma évszám négy számjeggyel ábrázolva %y szám két számjeggyel ábrázolva

52


A fenti függvények használatának bemutatására nézzünk egy két példát a teljesség igénye nélkül. Az első néhány lekérdezés során láthatjuk, hogy egy függvények futtatásához nem szüksé ges, hogy bármilyen az adatbázisban lévő adatot felhasználjunk, a harmadik példában egy az operációs rendszertől kapott adatot tudunk lekérdezni és megjeleníteni: A CHAR () függvény segítségével kiírathatunk szöveget a betű ASCII kódjának megadásával: A CHAR() függvény használata mysql> SELECT CHAR(77,121,83,81,76);

+----------------------------+ | char(77,121,83,81,76) |

+------------------------------ + | MySQL

|

+------------------------------ + 1 row in set (0.02 sec)

A POWER () függvény lehetőséget biztosít, hogy egy számnak valahányadik hatványát megkapjuk: A POWERQ függvény használata mysql> SELECT POWER(2,2);

+----------------+ | power(2,2)

|

+-------------- + |

4.000000

|

+-------------- + 1 row in set (0.05 sec)

A NOW() függvény segítségével megtudhatjuk a pontos dátu mot és időt: A now() függvény használata mysql> SELECT N O W (); +------------ ---------+ | n o w () 1 +------------ ---------+ | 2005-05-21 13:57:21 | +------------ ---------+ 1 row in set (0.04 sec)

A következő példákban látható, hogy már a lekérdezés ered ményeinek kiíratásakor szabályozhatjuk annak formáját, illetve módosítható a lekérdezés eredménye (2. példa), vagy kiíratha tunk olyan értéket, amit az adatbázisunk nem is tárol (3. példa):

53


Az DATE_ADD() függvény használata mysql> SELECT rendeles_id, datum, DATE_ADD(datum, interval 2 -> day) FROM rendeles; H--------------------------------------------- 1------------------------------------------ 1--------------------------------------------------------------------------------------------------------- h

|

rendeles_id |datum

|date_add(datum, interval 2 day)

|

H--------------------------------------------- 1------------------------------------------ 1--------------------------------------------------------------------------------------------------------- h

1 2 3 4

2005-05-10 2005-05-12 2005-05-17 2005-05-17

2005-05-12 2005-05-14 2005-05-19 2005-05-19

+-----------------+--------------- +------------------------------------------- + 4 rows in set (0.02 sec)

Az DAYNAMEQ függvény használata mysql> SELECT rendeles_id, DAYNAME(datum) FROM rendeles;

+---------------- +--------------------- + | rendeles_id | dayname(datum)

+--------------- +------------------- + 1 2 3 4

Tuesday Thursday Tuesday Tuesday

+--------------- +------------------- + 4 rows in set (0.00 sec)

Az utolsó példában kipróbálhatjuk, hogy a függvények nem csak a mezőlistában, hanem a w h e r e feltétel magadáskor is használható: Az DAYNAMEQ függvény használata szűréssel mysql> SELECT rendeles_id FROM rendeles WHERE DAYNAME(datum)= -> 'Thursday'; + --------------+ 1 rendeles_id | + --------------+ 2 1 1 + --------------+ 1 row in set (0.00 sec)

54


Az összes a MySQL által ismert függvény, illetve a függvények pontos paraméterei terjedelmi okok miatt nem kerülhetett bemu tatásra, a függvényekről bővebben az angol nyelvű MySQL refe renciakönyvben olvashatunk, amely elérhető a MySQL hivatalos oldalán is.

2.2.4.8. Táblák összekapcsolása Az eddigi példák egy adatbázisban csak akkor tudunk teljes körűen lekérdezni, ha az összes adatunk egy táblában van tárol va és 1 NF-jú. A mindennapi életben azonban nagyon ritkán ta lálkozhatunk ilyen adatbázisokkal, hiszen a magasabb normál forma elérése a hatékony működés szempontjából elengedhetet len. Több táblából való lekérdezés w h e r e feltétel megadásával vagy a JOIN használatával történhet. Kezelés szempontjából a w h e r e feltétel alkalmazása könnyebb, a JOIN használatának pedig több lehetőséget biztosít. Ha nem adjuk meg a kapcsoló feltételt a két tábla között, ak kor a táblák Descart szorzatát kapjuk, ami az összes tábla összes sorát párba állítja és kiírja: Táblák összekapcsolása (Descarte szorzata) tÉPttiilMáll mysql> SELECT rendeles_id, cikkszam, megnevezés, mennyiség -> FROM tetei, cikk; mennyiség | cikkszam megnevezés rendeles_id +------------- +---------- +------------- +----------- + csavar 10 | 1 1 csavar 15 | 1 21 csavar 1 40 8 1

toll 2 20 5 1 12 1 2 toll 40 20 toll 3 40 +------------- +---------- +------------- +----------- + 42 rows in set (0.00 sec)

Ahhoz hogy csak a megfelelő értékek jelenjenek meg az elsőd leges kulcsot és a külső kulcsot össze kell kapcsolni a w h e r e fel tételben:

55


Táblák összekapcsolása kapcsoló feltétellel mysql> SELECT rendeles_id, cikkszam, megnevezés, mennyiség -> FROM tetei, cikk WHERE cikk_id=cikkszam; | rendeles_id

cikkszam

1 1 1 1 2 2 3

1 21 40 50 20 40 40

megnevezés csavar ecset gitt toll olaj gitt gitt

| mennyiség | 10 15 8 4 5 12 20

+----------------- +------------- +----------------+-------------- + 7 rows in set (0.04 sec)

A WHERE feltételben természetesen további feltételeket is meg adhatunk, de ha helyes eredményű lekérdezést szeretnénk kap ni, akkor a további feltételeket és (and) operátorral kell kapcsol nunk a kapcsolófeltételhez. A második lekérdezésben láthatjuk, hogy a két táblának a kapcsolásra használt nevei megegyeznek, az ebből adódó problémát a tábla nevének megadásával oldhat juk meg: Táblák összekapcsolása kapcsoló feltétel használatával, szűréssel mysql> SELECT rendeles_id, cikkszam, megnevezés, mennyiség -> FROM tetei, cikk WHERE cikk_id=cikkszam -> and mennyiseg>10;

+------------------- +--------- +------------------ +------------- + | rendeles_id

|cikkszam

|megnevezés

| mennyiség |

+-------------------1 -------- +---------------- +------------+ 1 2 3

21 40 40

ecset gitt gitt

15 12 20

+----------------- +------------- +----------------+-------------- + 3 rows in set (0.03 sec)

56


A fenti lekérdezésekben nem kaphatunk információt arról, hogy van-e olyan megrendelésünk, amihez nincs megrendelő rendelve, illetve van-e olyan vevő, akinek nincs megrendelése. E probléma feloldására használható a j o i n kapcsolat alkalmazása. A „hagyományos” JOIN a w h e r e utáni feltétel kiváltására szolgál: Táblák összekapcsolása INNER JOIN segítségével mysql> SELECT vevonev, rendeles_id FROM vevő INNER JOIN -> rendeles ON rendeles.vevo_id=vevo.vevo_id; + --------------- +---------- --- + | vevonev | rendeles_id |

+----------------- +---------------- + Napfütő Rt. Napfütő Rt. Kőzúzó Kft Fuszekli Bt

1 2 3 4

+--------------------+----------------- + 4 rows in set (0.00 sec)

Ha azt szeretnénk, hogy az egyik tábla valamennyi sorát írja ki, a másikból pedig csak a kapcsolási feltételeknek megfelelőket, akkor az i n n e r helyett a l e f t (bal) vagy a r i g h t (jobb) paramé tert kell használnunk. Ha a FROM utáni táblából szeretnénk va lamennyi rekordot megjeleníteni, akkor a l e f t használandó, kü lönben a RIGHT parancsot: Táblák összekapcsolása LEFT és RIGHT JOIN segítségével mysql> SELECT vevonev, rendeles_id FROM vevő LEFT JOIN -> rendeles ON rendeles.vevo_id=vevo.vevo_id;

+-------------------- +----------------- + | vevonev

|rendeles_id

|

+------------------ +----------------+ Napfütő Rt. Napfütő Rt. Kőzúzó Kft Fuszekli Bt Csavargó R t . Nevenincs Bt.

1 2 3 4 NULL NULL

+------------------+----------------+ 6 rows in set (0.02 sec) mysql> SELECT vevonev, rendeles_id FROM vevő RIGHT JOIN ->rendeles ON rendeles.vevo_id=vevo.vevo_id;

+------------------+---------------- + | vevonev

| rendeles_id

|

+------------------+---------------- + Napfütő Rt. Napfütő Rt. Kőzúzó Kft Fuszekli Bt

1 2 3 4

H -------------------H ---------------- + 6 rows in set (0.00 sec)


57

A második lekérdezésben azért nincs NULL érték, mert a logi kai szabályok alapján, valamennyi megrendeléshez tartozik meg rendelő. 2.2.4.9. Beágyazott select használata A beágyazott SELECT használatára a MySQL 4.1-es verziójától van lehetőség, mely segítségével több egymás utáni SELECT használatát előzhetjük meg. Erre például akkor lehet szükség, és csak akkor használható, ha egy lekérdezés egyértékes eredmé nyét (belső select) akarjuk felhasználni egy másik lekérdezés (külső select) eredményének szűkítésére. Az átlagosnál drágább termékek kiíratására a következő parancsot tudjuk használni: Beágyazott SELECT használata mysql> SELECT megnevezés, egységár FROM cikk WHERE -> egysegar>(SELECT AVG(egységár) FROM cikk);

+--------------- +-------------+ |megnevezés

| egységár

|

H ----------------H ------------- + csavar olaj

12500 | 22500 |

+--------------- +-------------+ 2

rowsin set (0.02

sec)

2.2.5. Tranzakciók jelentősége és használata Az adataink módosítása során gyakran előfordul, hogy egymás utáni műveleteket szeretnénk végrehajtani, úgy, hogy biztosak lehessünk abban, hogy valamennyi művelet garantáltan végre hajtódjon. Ilyen rendszerek például a banki rendszerek, ahol az átutálások során biztosnak kell lennünk abban, hogy az egyik számláról leemelt összeg megjelenik a másik számlán. A tranzak ciók általában meg is történnek, de mint tudjuk egy áramszünet, vagy egyéb a rendszerre ható váratlan esemény ezt megakadá lyozhatja. Az adatbázisunk ebben az esetben inkonzisztenssé válik, amely a későbbi működés szempontjából helytelen ered ményeket okozhat. A tranzakció, úgy működik, mintha az utasí tás sorozatot egy utasításként hajtanánk végre. Ez a funkció azonban csak az InnoDB, valamint a BDB típusú táblák esetén működik. Alapértelmezésben a MySQL automati kusan végrehajtja a begépelt és helyes parancsainkat, ahhoz hogy a tranzakció kezelést kipróbáljuk, be kell kapcsolni ezt a funkciót a következő paranccsal: SET AUTOCOMMIT=0;

2. Az adatbázis-kezelés alapjai

Recommend Documents