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. Ezeket 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, valamint 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érhető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 kezelni, 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 of Data Systems Languages, vagyis az a d a tk e

22 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 szerint a jövő adatbáziskezelő-rendszereinek a következő tulajdonsá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 megengedett 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 programozni) 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 állapotba 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 Webes adatbázis-kezelés MySQL és PHP használatával 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ázisrendszereket. 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 által 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ódszereket történt meg, melynek részletei megtalálhatóak az adatbá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áziskezelé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 adatbázison belül a tábláknak egyedi nevük van. A táblák oszlopait attribútumoknak (oszlopoknak) nevezzük. Az attribútumok sorrendje 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útumá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ákbó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 kulcsok között, vagy NULL értékű kell lennie. A külső kulcs tényleges 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 érté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ázisterv 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 rendszert használunk. Ennél fogva a tervezés során nem kell odafi

24 Webes adatbázis-kezelés MySQL és PHP használatával 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űveletek során nyújt segítséget és feltétele annak, hogy az adatbázisunk ne kerüljön inkonzisztens állapotba, melynek eredményeként egy lekérdezés során hamis eredményeket kaphatunk. A redundancia megszüntetésének módja a normalizálás. A normalizálás során célszerű azt a harmadik normálforma eléréséig folytatni. A normalizálás folyamatát egy példán keresztül fogjuk megvizsgá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, viszont ne szerepeljenek benne olyan adatok, amelyek valamely attribútumból származtathatók (pl.: az egységárból és a mennyisé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 leké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 szerepelhet, vagy egy cikk több rendelésnek a része lehet, akkor ez a feltétel már nem teljesül.

2. Az adatbázis-kezelés alapjai 25 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 INF (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árlá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áblánkban a rendelés szám, valamint a cikkszám attribútumok (amelyek a TÉTEL tábla összetett elsődleges kulcsai) együtt biztosí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 Webes adatbázis-kezelés MySQL és PHP használatával 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 megszüntetjük a táblák egymásba ágyazását és ezzel új táblákat hozunk 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ődleges 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álasztottuk 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 szerepelhet 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ű normá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 megtekinthetjük az adatbázis-kezelő rendszerünk dokumentációját, ugyanis 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égighaladva nézzük meg milyen lehetőségeink vannak:

28 Webes adatbázis-kezelés MySQL és PHP használatával Attribútum Attribútum Attribútum megnevezése típusa hossza Megjegyzés RENDELÉS-2 rendelés száma numerikus 6 számjegy elsődleges kulcs dátum dátum vevőkód numerikus 5 számjegy külső kulcs határidő dátum VEVŐ vevőkód numerikus 5 számjegy elsődleges kulcs vevőnév szöveg 30 karakter külső kulcs vevőcím szöveg 50 karakter számlaszám numerikus 24 számjegy ':: '- -'.; új TÉTEL rendelés szám numerikus 6 számjegy összetett elsődleges cikkszám numerikus 8 számjegy kulcs mennyiség numerikus 4 számjegy CIKK 'j cikkszám numerikus 8 számjegy elsődleges kulcs megnevezés szöveg 15 karakter mennyiségi szöveg 5 karakter egység egységár numerikus 6 számjegy 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 tervezni, 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égrehajtá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értelmezettké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 angol terminusnak megfelelően pont(.). A két példánál jól láthatjuk, hogy a módosított tábla valamennyi 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ökkentsü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): ) mysql> DELETE FROM cikk WHERE cikk_id=51; Query OK, 1 row affected (0.03 sec) Egy rekord törlése 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 sokfé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 megtanuljuk, hogyan lehet bármilyen bonyolult lekérdezést megírni.

2. Az adatbázis-kezelés alapjai Kezdjük a legelején, a cikk tábla valamennyi sorának lekérdezésére a következő két utasítás egyaránt használható, a * karakter 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: 41 mysql> SELECT * FROM cikk; SELECT használata 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 csavar db 12500 2 csavarkulcs db 1000 20 olaj 1 22500 21 ecset db 312 40 gitt kg 249 50 toll db 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 csavar db 12500 2 1 csavarkulcs db 1000 20 1 olaj 1 22500 21 1 ecset db 312 40 1 gitt db 249 50 1 toll db 269 H----------------------------------- 1---------------------------------------------1---------------------- 1-----------------------------------h 6 rows in set (0.00 sec)

42 Webes adatbázis-kezelés MySQL és PHP használatával 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érdezé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 nevek 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 attribútum után megadott d e s c kiegészítéssel a rendezés megfordítható: 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 csavar db 12500 2 csavarkulcs db 1000 21 ecset db 312 40 gitt kg 249 20 olaj 1 22500 50 toll db 269 +-------------+----------------- +--------+------------- + 6 rows in set (0.00 sec) Az eddigi összes példa az adott tábla valamennyi sorát megmutatta számunkra, ami az esetek többségében nem túl szerencsé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álva, 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 gondot. A MySQL által használt operátorok: <, >, =,!=, <>, <=, >=.

2. Az adatbázis-kezelés alapjai 43 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; Összehasonlító operátorok használata 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 összekapcsolá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érdezé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ítségével módosítható, mindig a belső zárójelen belüli művelet érté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 1mennyisé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 Webes adatbázis-kezelés MySQL és PHP használatával 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 tudjuk ú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álható. Az egységár attribútumban a nem NULL értékű (kitöltött) rekordokat jeleníti meg: SELECT * FROM cikk WHERE egységár IS NOT NULL; 2.2.4.4. Tagság vizsgálata NULL érték lekérdezése Sokszor szükséges annak vizsgálata, hogy egy mező értéke beleesik-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 szabja 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áljuk, ha arra vagyunk kíváncsiak, hogy az általunk megadott felsorolá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.

2. Az adatbázis-kezelés alapjai 2.2.4.5. Mintaillesztés A szabvány ANSI SQL által biztosított eljárás, hogy a lekérdezéseinket, akkor is végre tudjuk hajtani, ha nem ismerjük az adott mező értékét. Természetesen ebben az esetben is rendelkeznü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övetkező példákban végigmegyünk a leggyakrabban használt úgynevezett 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 kezdődő rekordok íródtak ki: 45 Like használata mysql> SELECT * FROM cikk WHERE megnevezés LIKE 'csa%1; id megnevezés mennyi s egi_egys eg egységár 1 csavar db 12500 2 csavarkulcs db 1000 +---------- +---------------- H-----------------------+-------------h 2 rows in set (0.00 sec) A % operátor korlátlan számú karakter helyettesítésére szolgál ellentétben a V karakterrel, amely csak egy karakter helyettesí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 karaktertartományt [a-za-z] beírhatunk de csak akkor fog az adott feltételnek 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 helyen 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 +-------------+----------------- +------------------------ +--------------+ 1 csavar db 12500 2 csavarkulcs db 1000 21 ecset db 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áncsiak 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 írathatjuk ki a következő paranccsal:

2. Az adatbázis-kezelés alapjai 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űvelet elvégzésére is van lehetőségünk. Ezek a műveletek az átlagolás (a v g,az összesítés (SUM), a darabszám (COUNT), minimális érték (m i n ), maximális érték (m a x ) meghatározása. A példákon keresztül megnézhetjük, hogy ez a néhány művelet mennyire leegyszerű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 10.0000 20 5.0000 21 15.0000 40 13.3333 50 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 AX(mennyiség) FROM tetei GROUP BY -> cikkszam; +----------- +------------------- + cikkszam max(mennyiség) +--------- +--------------- + 1 10 20 5 21 15 40 20 50 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 rendelés során, mennyi tételt rendeltünk: mysql> SELECT rendeles_id, COUNT(rendeles_id) -> BY rendeles_id; +--------------- +------------------------ + rendeles_id count(rendeles_id) ' A COUNTQ függvény használata FROM tetei GROUP 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)

2. Az adatbázis-kezelés alapjai 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: 49 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 Leírása megadva) Szöveg függvények 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 szolgá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 kisbetű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 ascii( b ) char(77,121,83,81, 76) concat( My, S. QLj instrfbarangolásyg ol ) A példa eredménye 98, a b karakter ascii kódja MySQL MySQL 6 length ( darabj 5 left( MySQL,3) lower( MySQL ) MyS mysql ltrimf MySQL j MySQL repeat( MySQL,2) right( MySQL,3) MySQLMySQL 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 ab s (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 első előbbre van az ábécében, mint a második, különben 1 a szöveget nagybetűsre konvertál) a strcmp( MySQL, My SQL ) upper( MySQL ) 0 MYSQL Aritmetikai függvények alapvető aritmetikai műveletek, valamint az osztás egész részének 5 div 2 2 meghatározására szolgáló div Matematikai függvények a szám abszolút értékét adja vissza abs(-2) 2 Egy szöveg ere kódlát adja vissza 3259397556 crc32( MySQL ) maradványértéket ad vissza osztásnál mod (355,10) 5 a pi értékét adja 3.141593 vissza a számi szám2-dik hatványát adja power (2,2) 4 vissza véletlenszerű számot ad vissza 0 és 0.2358746951 254 egy között visszaadja a számot egészre kerekítve round (3,14) 3 megadja a szám gyökét sqrt(4) 2 Dátum és idő függvények Aktuális dátum lekérdezése curdateo 2005-05-20 aktuális idő lekérdezése curtimeo 12:03:18 egy teljes dátum idő date( 2005-05-20 szöegből visszaadja 12:4:22 ) a dátum értékét 2005-05-20 megadja a két dátumérték közötti távolságot napokban (csak a 4.1.1 verziótól) date( 2005-05-20-2005-05-25 ) 5

2. Az adatbázis-kezelés alapjai 51 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átumhoz adja hozzá a megadott fajta értéket. A leggyakrabban használt érték fajták: year, month, day, hour, minute, second) a dátum és az idő megjelenítési formá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átumban lévő nap angol nevét megadja a hónap nevér angolul megadja az aktuális időt a dátumból megadja 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) date_add( 2005-05- 12, interval 2 day) dateformat( 2005-05-23, '%Y. %M %d. %Wj; dayname( 2005-05- 23) monthname( 2005-05-23) now() time( 2005-05-23 12:24:38 ) timedeff(2005-05- 21 23:59:59.000001, -> '2005-05-20 01:01:01.000002'); 2005-05-14 2005. May 23. Monday Monday May 2005-May-21 12:24:38 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 leírás %a a nap neve röviden angolul (Sun...Sat) %W a nap neve angolul (Sunday...Saturdy %b a hónap neve röviden angolul (Jan...Dec) %M a hónap neve angolul (January...December) %H az órák kiírása 0-24-es formátumban /oh az órák kiírása 0-12-es formátumban %j a nap száma az évben /ou a hét száma %Y évszám négy számjeggyel ábrázolva %y %y szám két számjeggyel ábrázolva

52 A fenti függvények használatának bemutatására nézzünk egyké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: mysql> SELECT CHAR(77,121,83,81,76); +----------------------------+ char(77,121,83,81,76) +------------------------------ + MySQL +------------------------------ + 1 row in set (0.02 sec) Webes adatbázis-kezelés MySQL és PHP használatával A CHAR() függvény használata A POWER () függvény lehetőséget biztosít, hogy egy számnak valahányadik hatványát megkapjuk: mysql> SELECT POWER(2,2); +----------------+ power(2,2) +-------------- + 4.000000 +-------------- + 1 row in set (0.05 sec) A POWERQ függvény használata A NOW () függvény segítségével megtudhatjuk a pontos dátumot és időt: mysql> SELECT NOW(); +------------ ---------+ n ow() 1 +------------ ---------+ 2005-05-21 13:57:21 +------------ ---------+ 1 row in set (0.04 sec) A now() függvény használata A következő példákban látható, hogy már a lekérdezés eredmé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írathatunk olyan értéket, amit az adatbázisunk nem is tárol (3. példa):

2. Az adatbázis-kezelés alapjai 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 2005-05-10 2005-05-12 2 2005-05-12 2005-05-14 3 2005-05-17 2005-05-19 4 2005-05-17 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 Tuesday 2 Thursday 3 Tuesday 4 Tuesday +--------------- +------------------- + 4 rows in set (0.00 sec) Az utolsó példában kipróbálhatjuk, hogy a függvények nemcsak 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 + --------------+ 1 2 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 bemutatásra, a függvényekről bővebben az angol nyelvű MySQL referenciakönyvben olvashatunk, amely elérhető a MySQL hivatalos oldalán is. 2.2.4.8. Táblák összekapcsolása Webes adatbázis-kezelés MySQL és PHP használatával 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árolva és 1 NF-jú. A mindennapi életben azonban nagyon ritkán találkozhatunk ilyen adatbázisokkal, hiszen a magasabb normálforma elérése a hatékony működés szempontjából elengedhetetlen. 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, akkor a táblák Descart szorzatát kapjuk, ami az összes tábla összes sorát párba állítja és kiírja: tépttiilm áll Táblák összekapcsolása (Descarte szorzata) mysql> SELECT rendeles_id, cikkszam, megnevezés, mennyiség -> FROM tetei, cikk; rendeles_id cikkszam megnevezés mennyiség +------------- +---------- +------------- +----------- + 1 1 csavar 10 1 21 csavar 15 1 40 csavar 8 1 2 20 toll 5 1 2 40 toll 12 1 3 40 toll 20 +------------- +---------- +------------- +----------- + 42 rows in set (0.00 sec) Ahhoz hogy csak a megfelelő értékek jelenjenek meg az elsődleges kulcsot és a külső kulcsot össze kell kapcsolni a w h e r e feltételben:

2. Az adatbázis-kezelés alapjai 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 megnevezés mennyiség 1 1 csavar 10 1 21 ecset 15 1 40 gitt 8 1 50 toll 4 2 20 olaj 5 2 40 gitt 12 3 40 gitt 20 +----------------- +------------- +----------------+-------------- + 7 rows in set (0.04 sec) A WHERE feltételben természetesen további feltételeket is megadhatunk, de ha helyes eredményű lekérdezést szeretnénk kapni, akkor a további feltételeket és (and) operátorral kell kapcsolnunk 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 oldhatjuk 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 21 ecset 15 2 40 gitt 12 3 40 gitt 20 +-----------------+------------- +----------------+-------------- + 3 rows in set (0.03 sec)

56 Webes adatbázis-kezelés MySQL és PHP használatával 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. 1 Napfütő Rt. 2 Kőzúzó Kft 3 Fuszekli Bt 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 valamennyi 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. 1 Napfütő Rt. 2 Kőzúzó Kft 3 Fuszekli Bt 4 Csavargó R t. NULL Nevenincs Bt. 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. 1 Napfütő Rt. 2 Kőzúzó Kft 3 Fuszekli Bt 4 H-------------------H---------------- + 6 rows in set (0.00 sec)

2. Az adatbázis-kezelés alapjai A második lekérdezésben azért nincs NULL érték, mert a logikai szabályok alapján, valamennyi megrendeléshez tartozik megrendelő. 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: 57 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 12500 olaj 22500 +---------------+-------------+ 2 rows in 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égrehajtó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 tranzakció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 eredmé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 automatikusan 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;