Történet

Relációs algebra, relációs adatmodell

A relációs adatbázis-kezelo nyelvek a relációs (adatmodellű) adatbázisokat kezelik, dolgozzák fel. A relációs adatbázis-kezelo nyelvek mind ugyanazon közös matematikai alapra, a relációs algebrára épülnek. A relációs algebra a reláción végezheto műveleteket definiálja, és ezt - magát a relációs algebrát - használja fel minden relációs adatbázis-kezelo nyelv. A relációs algebra születését 1970-re keltezik, ugyanis ekkor jelent meg Ted Codd mára már híres cikke, mely azt javasolja - dióhéjban -, hogy az akkori bonyolult struktúrák helyett az adatokat tábla-szerűen kellene megjeleníteni, és minden tábla önálló relációként szerepelne az adatbázisban. Ez akkor meroben új elgondolás, ugyanis akkor ismerni kellett a programozónak az adatok tárolási struktúráját is. Itt csak a relációs algebrára épülo relációs adatbázis-kezelo nyelvet kell ismerni, és nincs szükség az adatbázis-kezelo rendszer háttérfolyamatainak ismeretére. (Az adatbázis-kezelo rendszer természetesen abszolút sajátos módon tárolhatja el a relációkat a késobbi gyors műveletvégzés elérése végett.)

A relációs algebra megalkotása persze még csak az alapját jelentette a relációs adatbázis-kezelo nyelveknek. Az elso relációs adatmodellen alapuló nyelvet úgyszintén Codd definiálta, és az ALPHA nevet adták neki. Ezután számos nyelv alakult ki és tűnt el, míg eljutottak az elso - számunkra fontos - szabványosított nyelvhez az SQL-hez.
 
 

Az SQL születése, verziói

Az adatbázis-kezelo rendszerek szabványosított nyelvévvé az SQL vált (SQL - Structured Query Language = Struktúrált LekérdezoNyelv). 1986-ban jelent meg az elso szabványosítás: ANSI SQL 86 (ANSI X3.1986) néven (ANSI - American National Standard Institute - Amerikai Nemzeti Szabvány Intézet). Késobb, 1987-ben az ISO is szabványosította (ISO - International Standard Organization - Nemzetközi Szabványügyi Szervezet). A szabványosítás természetesen nem jelentette, hogy minden gyártó be is tartaná a szabványt, így számos módosítás fejlesztés történt a késobbiekben. A következo szabványosítási folyamat 1989-ben zárult le, ezt nevezték el ANSI SQL 89-nek (ANSI X3-1989), amit úgyszintén az ISO is elfogadott és ISO89 néven (ISO9075:1989).

Az SQL nyelv mai általános formáját 1992-ben nyerte és az ISO szabványosította SQL92, vagy SQL2 néven (ISO:9075:1992).

Természetesen még ma is fellelhetok minimális különbséges más gyártók által szállított adatbázis-kezelo rendszerek SQL értelmezoiben. A különbségek minimálisak, így nem érdemes foglalkozni velük, ez mondhatnánk gyártó specifikus. Mi az alap nyelvi elemeket, és az általánosan elfogadott SQL92 szabványt alkalmazzuk.

A jövobe tekintve elokészületben van az SQL3 szabvány is mely az SQL2-t fejleszti tovább számos lehetoséggel, pl. rekurzió, objektumok használata, triggerek, stb.
 
 

SQL nyelvi parancsok

Hely és ido hiányában nem foglalkozunk magával a relációs algebrával, pontosabban a relációs adatmodellel. Nem felsooktatási jegyzetnek szánjuk ezen cikkeinket , csupán az érdeklodo Olvasót szeretnénk elkalauzolni eme információrengetegben és a szükséges alapokat megadni egy egyszerűbb, egy általános, adatbázisokkal foglalkozó probléma - feladat megoldásához. Igy itt csak az SQL parancsokra, nyelvi elemekre szorítkozunk. Akik komolyabban érdeklodnek a téma iránt, feltétlenül nézzenek utána a relációs adatmodellben végezheto műveletek elméleti leírásának, mert így átfogóbb és pontosabb képet alkothatnak az SQL nyelvi elemeirol.

Az SQL nyelvben minden parancs egy kulcsszóval kezdodik és pontosvesszovel (;) fejezodik be. Parancsnak parancs is lehet része. A parancsok lehetnek összetettek, az-az több részbol, alparancsból is állhatnak.

A kulcsszavakon kívül a parancs még operandusokat (argumentumokat) is tartalmaz, ezeken végez a parancs műveleteket. A parancsokat a könnyebb értelmezés végett több sorban, tördelve írjuk le (természetesen nem szükséges hasonlóan tördelve használni programozás esetén, sot ez sima SQL interpreter esetén meglehetosen nehézkessé tenné a feladatot).

Az SQL - mint talán már említettem - egy beépülo nyelv, így csak más programozási nyelvvel használható, felhasználói felülettel rendelkezo adatbázisokat használó programok készítésére. Természetesen az SQL nyelvet használhatjuk parancssor üzemmódban is, amikor egy erre alkalmas interpreterrel soronként hajtatjuk végre, a hasonlóan soronként begépelt parancsokat.

Tipikus eset, amikor a befogadó (host) nyelven megírjuk a felhasználói felületet az adatok feldolgozását és beszúrjuk az adatok kezeléséhez szükséges SQL parancsokat. Ennek a befogadó és beágyazó kapcsolatnak természetesen sok buktatója volt - mára már egyszerűen használható az SQL92-nek köszönhetoen - illetve napjainkban észreveheto, hogy kezd kibontakozni egy sokkal egyszerűbb és valóságosabb megközelítést megvalósító trend az OQL (Object Query Language). Az OQL esetén sokkal egyszerűbb a csatlakozás a befogadó nyelvvel, egyszerűbb, hisz egy lekérdezés eredménye objektumot generál.

Az alábbiakban az SQL parancsokkal ismerkedünk meg. Attekintjük szintaktikájukat, esetenként példákat is veszünk:

Adatbázis létrehozása

Az adatbázist (database) a CREATE DATABASE név; paranccsal hozhatjuk létre.

Táblák

Tábla létrehozása

Az SQL relációs adatmodellt kezel, így a legkisebb kezelheto egység a reláció, amit SQL-ben táblának (table) nevezünk. A táblát a CREATE TABLE paranccsal hozzuk létre. Szintaktikája:

CREATE TABLE táblanév (
    oszlopnév adattípus (méret) [,
    oszlopnév adattípus (méret),
    oszlopnév adattípus (méret) ] );

A tábla nevének (azonosítója) hossza és a névben alkalmazott karakterek típusa bizonyos korlátozás alá esik. A tábla azonosítója régebbi rendszerekben 8 karakter lehet, betűvel kezdodik, de tartalmazhat aláhúzást, számot (pl.: adatok_1). Az SQL92-ben már 18 karakter hosszú táblanevek is lehetnek és engedélyezett a #, @, $ karakterek használata is. A pontosabb használatot illetoen az alkalmazott SQL verzió (fordító) help-jét kell megtekinteni. A tábla nevét illetoen tehát nagy valószínűség szerint 18 karakter használható, de ne felejtkezzünk el arról, hogy az azonosító nem lehet SQL kulcsszó. (Hogy majd késobbi SQL példáinkat tekintsük, MySQL környezetben 64 karakter hosszú is lehet a név, kezdodhet akár számmal is - de nem állhat csak abból - tartalmazhatja a $ vagy _ karaktereket is. A névnél fontos még, hogy kis-/nagybetű érzékeny -e a rendszer. Ezt az alkalmazott operációsrendszer szabja meg esetenként.)

A tábla oszlopait adattípusokkal - és ezek méretével - határozzuk meg. Az oszlop névre (azonosítóra) hasonló szabályok vonatkoznak, mint a tábla névre, régebbi rendszerek csak 10 karakter hosszút, az SQL92 30 karakter hosszút, és pl. a fent említett MySQL rendszer 64 karakter hosszú nevet engedélyez. A névben szereplo, pontosabban alkalmazható karakterekre a fent elmondottak itt is érvényesek. (Itt is nézzük meg az adott rendszer specifikációit.)

Példa:

CREATE TABLE elado (
        eladoid INTEGER,
        vnev CHAR(16),
        knev CHAR(16),
        szuldatum DATE,
        kategoria CHAR,
        fizetes INTEGER
);
 
 

Adattípusok SQL-ben

Itt el kell különíteni két változatot: pl. a DBase féle változatok, ahol karakteresen vannak a számok is letárolva, így itt a szám leírt hosszúságát és nem az ábrázolhatósági tartományt adják meg. Más - fejlettebb - esetben pedig az adott nagyságú, pl. 8, 16, 32 biten ábrázolható számok intervallumát adják meg.
 
 
 
 
 

Típus
Karakteres tárolás esetén
Nem karakteres ábrázolás esetén
SMALLINT Hat jegyű egész szám lehet elojellel együtt:

-99 999 és 999 999 között

-32768 .. 32767

UNSIGNED: 0 .. 65535

INTEGER Tizenegy jegyű egész szám:

-9 999 999 999 és 99 999 999 999 között

-2147483648 .. 2147483647

UNSIGNED: 0 .. 4294967295

DECIMAL(x, y) x számjegyű fixpontos szám y tizedesjeggyel:

1 <= x <= 19 ; 0 <= y <= 18

Mind DOUBLE, lásd alább
NUMERIC(x, y) x számjegyű fixpontos szám y tizedesjeggyel:

1 <= x <= 20 ; 0 <= y <= 18

Lásd DECIMAL
FLOAT(x, y) x számjegyű (elojellel, tizedesjeggyel együtt) lebegopontos szám y tizedesjeggyel:

1 <= x <= 20 ; 0 <= y <= 18

-3.4028E+38 .. -1.17549E-38, 0,

1.17549E-38, és 3.4028E+38

CHAR(n) N karkater hosszú sztring: 1 <= n <= 254 N karkater hosszú sztring: 1 ? n ? 255
DATE Dátum típus, pl.: mm/dd/yy YYYY/MM/DD
LOGICAL Logikai típus: igaz vagy hamis (.T., .F.) True vagy False
BIT(n) Bit típus Bit típus
REAL Lebegopontos típus Környezet határozza meg
DOUBLE Lebegopontos típus, dupla pontosságú Környezet határozza meg
TIMESTAMP Dátum típus: dátum és idopont együtt YYYYMMDDHHMMSS
TIME Dátum típus: idopont HH:MM:SS

A nem karakteresen ábrázolt számok esetén mérvadó, hogy hány byte-on ábrázolják a számot. Igy ezt alább feltüntetjük, de felhívjuk a figyelmet, hogy ez platformonként változhat. (Alább ismertetünk az SQL92 szabványban nem rögzített típust is.):
 
 

Numerikus típusok

Típus
Méret
TINYINT 1 byte
SMALLINT 2 byte
MEDIUMINT 3 byte
INT 4 byte
INTEGER 4 byte
BIGINT 8 byte
FLOAT(4) 4 byte
FLOAT(8) 8 byte
FLOAT 4 byte
DOUBLE 8 byte
DOUBLE PRECISION 8 byte
REAL 8 byte
DECIMAL(M,D) M byte (D+2, ha M < D)
NUMERIC(M,D) M byte (D+2, ha M < D)

Dátum és ido típusok

Típus
Méret
DATETIME 8 byte
DATE 3 byte
TIMESTAMP 4 byte
TIME 3 byte
YEAR 1 byte

Visszatérve az SQL parancsokhoz:

Tábla törlése

A tábla törlését a DROP TABLE név; paranccsal oldhatjuk meg.
 
 

Tábla módosítása

A tábla módosítását az ALTER TABLE paranccsal tehetjük meg. Szintaktikája:

Uj oszlop hozzáadása:

ALTER TABLE táblanév
ADD ( oszlopnév adattípus (méret) [,
        oszlopnév adattípus (méret),
        oszlopnév adattípus (méret) ] );

Példa:

    ALTER TABLE eladok
    ADD ( szigszam CHAR(8) );
Meglévo oszlop törlése:

ALTER TABLE táblanév
DROP oszlopnév;

Példa:

    ALTER TABLE eladok
    DROP szigszam;
Meglévo oszlop módosítása:

ALTER TABLE táblanév
MODIFY ( oszlopnév adattípus (méret) [,
        oszlopnév adattípus (méret),
        oszlopnév adattípus (méret) ] );

Példa:

    ALTER TABLE eladok
    MODIFY ( vnev char(32) );
A tábla módosításánál, új oszlop felvételekor még nem ismertek az új oszlop értékei, így az új elemek helyére egy speciális érték az SQL-ben deklarált NULL érték kerül. (Megjegyzem létezik NOT NULL érték is.) Ez a legtöbb típus esetén helyettesíti az ismeretlen értéket, míg egyes típusok esetén nem használható. Alapértelmezés szerinti típust akár új vagy meglévo tábla módosításakor is megadhatunk az alábbi kulcsszó használatával: DEFAULT a típusnak megfelelo érték; .
 
 

Uj sor hozzáadása

Uj sor hozzáadása a táblához az INSERT paranccsal történik, szintakszisa:

INSERT INTO táblanév
[ ( oszlopnév lista) ]
VALUES ( értéklista );

A hozzáadott sor fizikailag az utolsó sor után tárolódik el. Az oszlopnév listánál felsorolhatjuk, hogy mely oszlopokba kívánunk értéket írni, így csak azok értékét kell - sorrend helyesen - reprezentálni a VALUES értéklistában. Amennyiben elhagyjuk az oszlopok nevének felsorolását, akkor az összes oszlopba kell értéket írnunk (avagy az értéklistának az összes oszlophoz kell - típus helyes - értéket tartalmaznia). Amennyiben a bevitel során nem ismert egy oszlop értéke használhatjuk az univerzális NULL értéket.

Példa:

    INSERT INTO eladok
    VALUES (9, "Kovács", "Péter", "1950-01-01", "C", 35000);

    INSERT INTO eladok
    (eladoid, vnev, knev, szuldatum, kategoria)
    VALUES (10, "Kovács", "Jakab", "1950-01-01", "C");

Az elso példában minden oszlopot feltöltünk értékkel. A másodikban a fizetés ismeretlen, így felsoroljuk a feltöltendo oszlopokat, és magadjuk a szükséges értékeket. A nem felsorolt oszlop(ok) értéke NULL lesz.
 
 

Uj sor hozzáadása, más táblákból való értékekkel

INSERT INTO táblanév
[ ( oszlopnév lista) ]
SELECT ... ;

Az új sor(ok) értékeit a SELECT parancs által (lásd alább) kiválasztott tábla sorának, vagy sorainak értékeivel tölti fel.
 

A tábla sorainak módosítása

A tábla meghatározott soraiban a meghatározott értékeket módosíthatjuk az UPDATE paranccsal, szintaktikája:

UPDATE táblanév
SET oszlopnév = kifejezés
        [, oszlopnév = kifejezés ...]
[WHERE feltétel];

A megadott táblában az adott oszlopban azon sor értékeit módosítja, melyek megfelelnek a WHERE kritériumának a kifejezésben megadott módon. A WHERE feltétel tartalmazhat további SELECT parancsokat is. Amennyiben a WHERE feltétel nincs jelen, akkor az összes sor módosul.

Példa:

UPDATE eladok
SET fizetes = 1.2*fizetes
WHERE fizetes < 22500;
Ez a példa könyörületességet mutat a minimálbéren dolgozok felé, 20%-kal növeltük bérüket.
 

A tábla sorainak törlése

A tábla magadott sorainak törlése a DELETE paranccsal történik, szintakszisa:

DELETE FROM táblanév
[WHERE feltétel];

A tábla azon sorait törli, amelyeknél teljesül a WHERE-nél megadott feltétel. A WHERE feltétel tartalmazhat további SELECT parancsokat is. Amennyiben a WHERE feltétel nincs jelen, akkor az összes sor törlodik, de a tábla szerkezete, felépítése nyílván megmarad (hisz azt csak a DROP TABLE név; paranccsal törölhetjük).

Példa:
        DELETE FROM eladok
        WHERE eladoid = 10;

A 10-es eladoid-jű eladót leépítés miatt elbocsátották. (A nyilvántartásból törölték.)
 

Lekérdezés az adatbázisból

Az adatbázis-kezelés majd legfontosabb művelete az adatbázisból történo lekérdezés. Persze a többi művelet sem haszontalan, de valójában csak a lekérdezéshez, az adat visszanyeréshez segédkeznek. A SELECT parancs feladatának megfeleloen talán a legbonyolultabb parancs, számos részbol áll. A parancsot - ahogy a többit is - csak szintaktikailag ismertetjük, példát itt nem veszünk, erre késobb térünk rá egy meghatározott adatbázis-kezelo rendszer esetén. Szintakszis:

SELECT [DISTINCT | ALL] oszlopnév, ...
    [INTO vátozónév lista]
    [FROM tábla lista, ...
        [WHERE feltétel]
        [GROUP BY oszlopnév, ...]
        [HAVING feltétel]
        [UNION | INTERSECT | MINUS SELECT ...]
        [ORDER BY oszlopnév | oszlop-sorszám, ... [ASC|DESC]]
    ];

Bontsuk részekre a SELECT parancsot, hogy áttekinthessük az alparancsokat.
 

SELECT kifejezés;

    Pl.: SELECT 1+1;
    => 2
Némely SQL változatban a FROM tábla referencia használata nélkül, magában is használhatjuk.
 

SELECT ... FROM alparancs

SELECT [DISTINCT | ALL] oszlopnév, ... | *
FROM tábla lista;

A FROM után felsorolt táblákból a megadott oszlopokat, vagy * esetén az összeset kilistázza, illetve más körülmények között: feldolgozásra átadja. Fontos megjegyezni, hogy az oszlopnév listánál nem csak az oszlopnevet, hanem oszlopokból képzett kifejezéseket, illetve aggregáló függvényeket is megadhatunk, ezeket közösen származtatott oszlopoknak nevezzük.

Példák:

  • A vezeték és keresztnév egy oszlopban listázódik ki:

  • SELECT eladoid, vnev + knev, fizetes
    FROM elado;
  • A fizetés mezo nettó értékét tekintsük (kb. szorozzuk be 0.55):

  • SELECT eladoid, vnev, knev, 0.55*fizetes
    FROM elado;
  • Számítsuk ki jelenleg hány eladó dolgozik a cégnél (aggregáló függvény):

  • SELECT COUNT(*)
    FROM elado;
  • Jelenítsük meg a cégnél dolgozó eladók összes fizetését:

  • SELECT SUM(fizetes)
    FROM elado;
     
  • Jelenítsük meg az eladó fizetését, az eladók átlag fizetését:

  • SELECT vnev, knev, fizetes, AVG(fizetes)
    FROM elado;
     
  • Használható továbbá a MIN(), és MAX() alapfüggvények
  • Az aggregált függvényeknél a NULL értékek nem kerülnek beszámításra.
  • DISTINC | ALL funkció

  • Ha a relációban több azonos sor is van, akkor a DISTINCT funkcióval az azonosakat kiszűrhetjük:

SELECT DISTINCT vnev
FROM elado;

Ennek hatására az elado táblából az összes név kilistázódik, csupán a többször szereploek közül az elso fog szerepelni, avagy csak az összes különbözo név listázódik ki. Itt fontos, hogy csak a teljesen megegyezo sorok szűrodnek ki, nyílván nem elég adott mezonek megegyeznie. Az ALL funkció pedig a DISTINCT ellentéte, avagy az alapeset amikor minden sor kilistázódik a lekérdezés során.
 

WHERE alparancs, sorok kiválasztása

A WHERE alparancsnál feltételként egy logikai kifejezést kell megadnunk, azon sor(ok) mely(ekre) igaz az értéke, a rendszer kiválasztja oket, szintakszis:

WHERE feltétel

A feltételben természetesen használhatóak az összehasonlító operátorok (<, <=, >, >=, =, !=, <>, <=>), és a logikai kapcsolatok (AND - és, OR - vagy, NOT - negálás) is. Amint fent elmondtuk, hogy az aggregált függvényeknél a NULL értékek (a vizsgált sor adott oszlopánál) nem számítanak bele a műveletbe, úgy itt is elmondható, hogy az összehasonlítás során nem történik hajtódik végre a művelet az adott oszlopban található NULL értéket tartalmazó sor esetén, így az nem szerepel az eredménylistában.

Példa:

  • Ez a feltétel a leheto legegyszerűbb feltétel, a 45000-nél többet keresok adatait listázza ki:
SELECT eladoid, vnev, knev, fizetes
FROM elado
WHERE fizetes > 45000;
  • Az alábbi feltétel egy összetett feltétel, mely a B illetve nagyobb fizetés kategóriájú, és 45000-nél többet keresoket listázza ki:
SELECT eladoid, vnev, knev, fizetes, kategoria
FROM elado
WHERE fizetes > 45000 AND kategoria > 'A';
  • A dátum vizsgálatára mindig ügyelni kell, érdemes az adott SQL rendszer dokumentációját, illetve az adott operációs rendszer lehetoségeit áttekinteni, hogy milyen formában várja az SQL feldolgozó a feltételt:
SELECT eladoid, vnev, knev, fizetes, szuldat
FROM elado
WHERE fizetes > 45000 AND szuldat > "1975.01.01";

Van ahol nem "" jelek közé kell tenni a dátumot, hanem {} közé.
 
 

Predikátumok használata

  • IN (érték lista, ...)
Igaz, ha a keresett mezo megtalálható az értéklistában.

Példa:

SELECT eladoid, vnev, knev
FROM elado
WHERE vnev IN ("Kovács", "Tóth");

Eredményül a Kovács és Tóth nevű eladókat adja ki. (Ekvivalens a feltétel a: WHERE vnev = "Kovács" OR vnev = "Tóth";)

  • NOT IN (érték lista, ...)
Igaz, ha a keresett mezo nem található meg az értéklistában.
  • BETWEEN min AND max
Igaz, ha a keresett mezo értéke a megadott minimum és maximum között van.

Példa:

SELECT eladoid, vnev, knev, fizetes
FROM elado
WHERE fizetes BETWEEN 20000 AND 30000;

Eredményül a 20 és 30 ezer közötti fizetéssel rendelkezoket listázza ki. (Ekvivalens a feltétel a: WHERE fizetes >= 20000 AND fizetes <=30000;)

  • INTERVAL(X, N1, N2, N3, ..., Nn)
Az X intervallumát keresi: 0-val tér vissza, ha X < N1, 1-gyel tér vissza, ha X < N2, 2-vel tér vissza, ha X < N3; (Nem minden SQL verzióban használható.)
  • kifejezés LIKE kifejezés [ESCAPE 'escape-karakter']
Altalában szövegek összehasonlítására használt predikátum. Az alábbi helyettesíto-karakterek (jocker karakterek) használhatóak:
  • % - bármely karakter helyettesítése (még üres karakteré is)
  • _ - Pontosan egy karaktert helyettesít
Az összehasonlítás azokat az oszlopokat tartalmazó sorokat adja vissza, mely(ek)re a feltétel igaz. Az alábbi egyszerű példában pedig 1-et ad, ha igaz a feltétel értéke, ellenben ha hamis, akkor 0-t.

Példa:

SELECT "Próba" LIKE "P%"
=> Eredmény: 1 (mert bármely a P utáni karaktert helyettesít)

SELECT "Próba" LIKE "Pr_b%"
=> Eredmény: 1 (mert a 3. karakter szabadon választott és a 4. karaktertol pedig bármi elhelyezkedhet)

SELECT "Próba" LIKE "Próba%"
=> Eredmény: 1 (mert igaz, hogy nincs a Próba szó után újabb karakter, de a % helyén bármilyen karakter, vagy akár üres karakter is állhat)

SELECT "Próba" LIKE "Próba_"
=> Eredmény: 0 (mert a _ jel pontosan egy karaktert helyettesít)

SELECT "Próba" LIKE "%r%"
=> Eredmény: 1 (mert van benne r betű)

SELECT "Jelek:!@#$%^&*()" LIKE "%~%%" ESCAPE '~';
=> Eredmény: 1 (mert % jelet keresünk és van benne. Mivel a % jel fenntartott jel, egy speciális ESCAPE jelet teszünk elé, ami megkülönbözteti a sima % jeltol.)

Sot van, amelyik SQL rendszerben megengedett a numerikus összehasonlítás is:

SELECT 10 LIKE "1%"
=> Eredmény: 1 (mert a 2. karakter helyén bármi állhat)

  • kifejezés NOT LIKE kifejezés [ESCAPE 'escape-karakter']
Funkciója hasonló a kifejezés LIKE kifejezés [ESCAPE 'escape-karakter']-hez, csupán azon elofordulásokat keresi, ahol nem található meg a megadott kifejezés.
 

A GROUP BY alparancs, sorok csoportosítása

Gyakran van szükség arra, hogy a sorokat valamely oszlop (vagy oszlopok) azonos értékei szerint csoportosítsuk. A csoportosítás során kialakult csoportokban más oszlop (vagy oszlopok) csoportbeli értékét összegezhetjük, átlagolhatjuk, stb. Az alparancs szintakszisa:

GROUP BY oszlopnév [, oszlopnév ...]

Az operandusként megadott oszlopnévre bizonyos megkötések vannak:

  • minden SELECT-beli oszlopnévnek vagy a GROUP BY-ban, vagy a SELECT-ben felírt aggregáló függvény argumentumában kell szerepelnie
  • nem lehet származtatott oszlop neve (kivéve, ha SELECT-ben aggregáló függvény argumentumában szerepel)
Példa:

SELECT kategoria, AVG(fizetes)
FROM eladok
GROUP BY kategoria;

Eredmény: Az egyes kategóriáknak megfelelo átlag fizetést adja meg. Mert: A - GROUP BY-nál - megadott oszlop (vagy, ha több van, akkor ezen belül a második oszlop ezen belül a harmadik, ...) azonos értékei szerint csoportosítja a sorokat. Az így kapott azonos sorokra a SELECT-nél megadott aggregáló függvényt - most az átlag: AVG()-t - alkalmazzuk, így az egy-egy kategóriához tartozó sorok között hajtódik végre a művelet, és megkapjuk a kategóriánkénti átlagfizetést.

Amennyiben a SELECT-ben egy újabb oszlopot reprezentálunk, pl.: vnev, akkor annak elso elofordulása jelenik meg az eredményben.
 

HAVING alparancs, sorok csoportosítása feltétellel

A fent leírt GROUP BY oszlopnév, ... alparancs esetén minden csoport eredménye megtalálható a végeredményben. Amennyiben csak adott csoportokra vagyunk kíváncsiak, akkor a HAVING feltétel alparanccsal a GROUP BY-t megtoldva elérhetjük a feltételnek nem megfelelo sorok kiszűrését.

Példa:

SELECT kategoria, AVG(fizetes)
FROM eladok
GROUP BY kategoria
HAVING AVG(fizetes) < 22500;

Azon kategóriákat listázza ki, ahol az átlagfizetés kisebb, mint 22500 forint. (pl. minimál bér alatt dolgozó kategóriai beosztás.)
 

ORDER BY alparancs, a lekérdezés eredményének rendezése

A bármely alparancsokkal kialakított eredményt valamely oszlop vagy oszlopai szerint rendezhetjük. Szintakszisa:

ORDER BY oszlopnév | oszlop-index [ASC | DESC] [,
                  oszlopnév | oszlop-index [ASC | DESC], ...]

Az alparancs az argumentumban megadott oszlop(ok) szerint rendez. A rendezés történhet növekvoleg AVG kulcs, és csökkenoleg, DESC kulcs. Amennyiben több oszlopnevet adunk meg, pl.: vnev, knev, akkor az utóbb megadott oszlop szerint lesz rendezve az elobbi oszlop szerint megegyezo sorok értéke (és ez természetesen igaz az alábbi oszlopokra is). Avagy, ha több pl. "Kovács" van, akkor a knev (keresztnév) oszlop által rendezodik az összes Kovács neve. A rendezést tekintve bármilyen típusú oszlop használható. Viszont fontos, hogy az ORDER BY után szereplo oszlop(ok)nak szerepelnie kell a SELECT utáni oszlop-listában továbbá, ha számmal (indexxel) adjuk meg az oszlopokat, akkor a SELECT utáni oszlop-listában található sorszámot kell megadni.

Pl.:

SELECT vnev, knev, eladoid, fizetes
FROM elado
ORDER BY vnev, knev, eladoid;

Abszolút abc-sorrendbe teszi az eladók nevét, ha esetleg így is lenne egyezoség, akkor az eladó-azonosító (eladoid) alapján történik a további rendezés,

SELECT eladoid, vnev, knev, fizetes
FROM elado
ORDER BY eladoid;

Az eladó-azonosító által történik a rendezés, itt nincs szükség további rendezési kulcsokra, ugyanis mindegyik különbözo.
 
 

Következo cikkünkben folytatjuk az SQL parancsokkal, továbbá bemutatjuk a MySQL környezetet, és ebben példákat is veszünk mai számunk parancsaira.

A MySQL környezet elérheto a http://www.mysql.com helyen, itt kell regisztráltatni magunkat a Win32-es programok letöltése végett. További MySQL-lel kapcsolatos segédanyagok elérhetoek magyar szerverrol is - a linkek a cikk mellett találhatók.