SQL programozási nyelv

A Wikipédiából, a szabad lexikonból.

Structured Query Language: Strukturált lekérdező nyelv.

Angol nyelvterületen 'eszkjuel' a kiejtése. A hagyományokhoz való hűség jegyében sokan 'szíkvel'-nek ejtik, ugyanis korábban Structured English Query Language (SEQUEL) volt az elnevezés, és ezt rövidítették le.

A relációs adatbázis-kezelők általában az SQL nyelven programozhatók. Az SQL alapvető utasításait közel egyformán valósítják meg, de a később beépült nyelvi elemek körében nagyon nagy az eltérés, az inkompatibilitás, emiatt számos SQL nyelvjárásról beszélhetünk.

Jellegét tekintve ez a programozási nyelv részben procedurális, részben deklaratív.

Tartalomjegyzék

[szerkesztés] Az SQL története

Az SQL alapjait az IBM-nél fektették le, még az 1970-es években. Elvi alapot a relációs adatmodell szolgáltatott, amit Edgar F. Codd híres 12 szabályával írt le először, 1970-ben.

Az IBM, az Oracle és más gyártók is érdekeltek voltak egy szabványos lekérdező nyelv kifejlesztésében, amivel a relációs adatbázisok programozhatók. Az iparági összefogással létrejött ANSI NCITS (National Committee on Information Technology Standards) H2 csoport lerakta az SQL alapjait.

A szabványt az ANSI (Amerikai Nemzeti Szabványügyi Intézet – American National Standards Institute) 1986-ban, az ISO (Nemzetközi Szabványügyi Szervezet – International Organization for Standardization) 1987-ben jegyezte be. Az első változatot SQL86 néven is szokták emlegetni.

Az SQL-t folyamatosan továbbfejlesztették, és négy jelentős kiadást különböztetünk meg:

  • SQL86
  • SQL89
  • SQL92
  • SQL99

Az első kivételével mindegyik szabvány többszintű megvalósítást tesz lehetővé a gyártóknak (belépő szintű, közepes vagy teljes). Általában a későbbi szabványok belépő szintjei az előző szabvány teljes szintjeinek felelnek meg.

[szerkesztés] Az SQL nyelv

A nyelvi elemeket szokásos adatdefiníciós (Data Definition Language, DDL) és adatkezelési (Data Manipulation Language, DML) részekre bontani. A nyelvben az utasításokat a pontosvessző választja el egymástól.

[szerkesztés] Adatdefiníciós utasítások

[szerkesztés] CREATE

Adatbázis objektum létrehozása. Példa adatbázis tábla definíciójára:

CREATE TABLE Szamla (
  Szamlaszam NUMERIC(24),
  Tulajdonos VARCHAR(60),
  Nyitas DATE,
  Allapot VARCHAR(1),
    PRIMARY KEY (Szamlaszam)
);

A fenti példa létrehoz egy adatbázis táblát, 4 oszloppal.

[szerkesztés] ALTER

Adatbázis-objektum módosítása. Példa:

ALTER TABLE Szamla 
  MODIFY Szamlaszam VARCHAR(26);

A fenti példa megváltoztatja egy adatbázis tábla egy oszlopának típusát.

[szerkesztés] DROP

Egy adatbázisbeli objektum megszüntetése. Példa:

DROP INDEX Szamla_1;

A fenti példa megszüntet egy indexet.

DROP TABLE egy_tabla;

Ez pedig egy adattáblát szüntet meg.

[szerkesztés] COMMENT

Megjegyzést fűz egy adatbázis-objektumhoz. Példa:

COMMENT ON TABLE Szamla IS 'Ügyfelek bankszámlaszámai';
COMMENT ON COLUMN Szamla.Allapot IS 'Számla állapota: "N" – Normál, "D" – Törölve';

A fenti példa megjegyzéseket fűz egy táblához és annak egy mezőjéhez.

[szerkesztés] Adatkezelő utasítások

[szerkesztés] SELECT

Az SQL talán leggyakrabban használt utasítása a lekérdezés. Ez a nyelvi elem inkább deklaratívnak tekinthető, mint procedurálisnak, hiszen a felhasználó (programozó) csak az eredményhalmaz mezőit (oszlopait) és a halmaz felépítésének feltételeit határozza meg, a leválogatási algoritmus elkészítése az adatbázis-kezelő feladata.

A SELECT utasítás az adatok egy halmazát válogatja ki egy táblázatba a relációs adatbázisból, és teszi elérhetővé valamilyen technikával a felhasználó számára. Mivel elég nagy adatmennyiségekről lehet szó (szélsőséges esetben az egész adatbázisról), ezért a halmaz általában szekvenciálisan olvasható. Egy mutató (kurzor) mozgatható az eredmény halmazon előre vagy hátra, és kiolvasható, hogy milyen adatok vannak a mutató alatt. Ha a mutató az eredményhalmaz végére vagy elejére ért, azt különleges jelzéssel tudatja az adatbázis-kezelő (EOF – End of File – állomány vége, illetve BOF – Beginning of File, állomány eleje)

Példa:

SELECT COUNT(*), Tulajdonos
FROM Szamla
WHERE Allapot = 'N'
GROUP BY Tulajdonos
HAVING COUNT(*) > 1
ORDER BY Tulajdonos

A fenti példa kilistázza azokat a személyeket, akiknek egynél több aktív bankszámlája van. Az első oszlopban az aktív bankszámlák száma, a másodikban a tulajdonosok neve olvasható. A táblázat a tulajdonosok neve szerinti emelkedő sorrendben jelenik meg.

A SELECT utasítás több szakaszból állhat, amelyek közül majdnem mindegyik elhagyható, ha az szükséges. Az egyes szakaszok magyarázata:

[szerkesztés] SELECT

Az eredményhalmaz oszlopait kell itt felsorolni. Nagyon hasznos, hogy további SELECT-ek is lehetnek benne!

Példa:

SELECT Vevo.Nev, (SELECT SUM(Osszeg) FROM Rendeles WHERE VevoID = Vevo.ID) RendelesOsszeg

A fenti példa a vevő neve mellett megjeleníti az eddigi rendeléseinek összegét is.

Összetettebb példa:

SELECT munka_szám FROM munka
WHERE óraszám*óradíj = (
  SELECT max(óraszám*óradíj) FROM munka
  );

A lekérdezés megkeresi a legnagyobb árbevételű munkáinkat. – akkor használható jól, ha több is van belőle.

[szerkesztés] FROM

Meghatározza, hogy mely adatbázis-táblákból szeretnénk összegyűjteni az adatokat.

Példa:

SELECT *
FROM Beteg, Kezeles

A fenti példa az összes beteggel összepárosítja az összes kezelést (Descartes-szorzatot képez). Ennek persze nincs túl sok értelme, hiszen mi minden beteghez csak a hozzá tartozó kezelést szeretnénk látni. Ezt így fogalmazhatjuk meg:

SELECT *
FROM Beteg KEY JOIN Kezeles

A fenti példa akkor működik, ha van definiált külső kulcs a Kezeles tábláról a Beteg táblára. Egyes SQL kiszolgálók (pld. Oracle) ezt a fajta összekapcsolást nem támogatják, hiába definiálunk külső kulcsot.

[szerkesztés] WHERE

Szűrési feltételeket fogalmaz meg, amelyek szűkítik az eredményhalmazt (a Descartes-szorzathoz képest). Példa:

SELECT *
FROM Beteg, Kezeles
WHERE Beteg.ID = Kezeles.BetegID AND Kezeles.Datum = CURRENT DATE

A fenti lekérdezés visszaadja, milyen kezeléseket végeztek ma, és melyik betegeken. A WHERE szakaszban a Boole-algebra kifejezései használhatók, OR, AND és NOT operátorokkal.

[szerkesztés] GROUP BY

Egyes sorok összevonását, csoportosítását írja elő az eredménytáblában. Példa:

SELECT COUNT(*), Tulajdonos
FROM Szamla
WHERE Allapot = 'N'
GROUP BY Tulajdonos

A fenti példa a Tulajdonos oszlop alapján csoportosítja a sorokat. A SELECT részben lévő COUNT(*) egy-egy csoport sorainak számát adja vissza, az összevonás előtt.

[szerkesztés] HAVING

A WHERE-hez hasonlóan itt is szűrést fogalmazhatunk meg, azonban itt a csoportosítás utáni eredményhalmazra. Példa:

SELECT COUNT(*), Tulajdonos
FROM Szamla
WHERE Allapot = 'N'
GROUP BY Tulajdonos
HAVING COUNT(*) > 1

Az előző példához képest itt annyi a módosulás, hogy csak azok a csoportok jelennek meg, amelyek egynél több sorból lettek összevonva.

[szerkesztés] ORDER BY

Az eredményhalmaz rendezését adja meg. Példa:

SELECT *
FROM Beteg
ORDER BY Szuletes DESC

A fenti példa a betegek listáját adja vissza, születési dátum szerint sorba rendezve, elöl a legfiatalabb beteggel.

[szerkesztés] Lekérdezési terv

Angolul query plan.

A kurzor létrehozásának technikája adja az SQL kiszolgálók igazi erejét. Nem mindegy ugyanis, hogy sikerül-e a táblákat megfelelő oszlopok (és indexek!) segítségével összekapcsolni, és ezekből kurzort készíteni, vagy pedig átmeneti táblát kell létrehozni az eredményeknek.

Az egyes relációs adatbázis-kezelők egymástól igen eltérő algoritmusokat használnak a lekérdezési tervek megalkotásához. Gyakori a szabály-alapú (rule-based), és a költség-alapú (cost-based) lekérdezési terv készítés. A költség-alapú lekérdezési tervhez ismerni kell az adatok statisztikai eloszlását: átlagát, szórását stb. A szabály-alapú lekérdezéseknél elegendő csak a relációs adatbázis szerkezetének ismerete. A legtöbb relációs adatbázis-kezelő a kettő valamilyen kombinációjával dolgozik.

Sok gyártó SQL megvalósításában lehetséges a keresési stratégia befolyásolása, úgynevezett programozói lekérdezési tippek (query hints) segítségével. Azonban minél jobb egy adatbázis-kezelő, annál kevésbé szükséges ezek használata.

[szerkesztés] INSERT

Adatokat ad hozzá egy táblához. Példa:

INSERT INTO Szamla (Szamlaszam, Tulajdonos, Nyitas, Allapot)
VALUES (123456, 'H. Kovács Géza', '1996.05.14.', 'N');

[szerkesztés] UPDATE

Módosítást hajt végre az adatokon. Példa:

UPDATE Szamla SET Allapot = 'D' WHERE Szamlaszam = 123456;

A fenti utasítás megváltoztatja az egyik számla állapotát.

[szerkesztés] DELETE

Adatokat töröl egy táblából. Példa:

DELETE FROM Beteg WHERE TAJ = '123 456 789';

Ez az utasítás annak a betegnek, akinek a TAJ száma:123 456 789, törli az összes adatát a Beteg táblából.

[szerkesztés] Egyéb utasítások

Az SQL-t az idők során kiegészítették olyan tulajdonságokkal, hogy a programozók képesek legyenek benne bonyolult algoritmusokat is írni. Ez akkor válhat szükségessé, ha például komoly adatkezelési feladatokat szeretnénk az ügyfél-oldalról a kiszolgáló-oldalra áthelyezni, az ott elérhető sokkal nagyobb tejesítmény miatt. De az is lehet, hogy csak egyszerűsíteni akarjuk a programozást felhasználói függvények létrehozásával (például szükségünk lenne egy olyan függvényre, ami a TAJ számból kiszedi a szóközöket).

Az SQL nyelv részei a változókezelés, elágazások, ciklusok kezelése, kivételkezelés stb.

A legnagyobb különbségek az SQL kiszolgálók között éppen ezeknél a nyelvi elemeknél adódik: ahány gyártó, annyiféle megvalósítás.

Az egyéb nyelvi elemek szemléltetésére álljon itt egy Sybase ASA SQL példa:

CREATE FUNCTION DigitsOnly(IN M_Nev VARCHAR(30))
RETURNS VARCHAR(30)
BEGIN
  DECLARE M_Result VARCHAR(16);
  DECLARE i INTEGER;
  SET i = 1;
  SET M_Result = ;
  WHILE (i <= LENGTH(M_Nev)) LOOP
    ID SUBSTR(M_Nev, i, 1) BETWEEN '0' AND '9' THEN
      SET M_Result = M_Result + SUBSTR(M_Nev, i, 1)
    END IF;
    SET i = i + 1;
  END LOOP;
  IF m_Result =  THEN
    RETURN(Null)
  ELSE
    RETURN(M_Result)
  END IF;
END;

A fenti függvény a bemenetére küldött szövegből csak a számjegyeket hagyja meg.

[szerkesztés] Jelentős különbségek az SQL megvalósítások között

[szerkesztés] Adattípusok

  • Az Oracle rendszereiben nincs NUMERIC, helyette a NUMBER-t kell használni
  • Az Oracle nem támogatja a VARCHAR-t, helyette a VARCHAR2-t javasolja
  • Az Oracle nem támogatja a LONG VARCHAR-t, helyette a CLOB-ot javasolja
  • Oracle-ben a DATE dátumot és időt is tartalmazhat, más rendszerekben ez csak dátum lehet
  • Egyes megvalósításokban (pld. PostgresSQL) létezik általános típusú adat is, amelyben akármit és akármekkora terjedelemben tárolhatunk
  • Némelyik rendszerben létezik a SMALLINT vagy az INTEGER típus is, mint szabványon kívüli elemek
  • Van olyan rendszer, amiben a BOOL típust is megvalósították

[szerkesztés] Összekapcsolás

Az SQL kiszolgálók egy része támogatja a SELECT-FROM szakaszba írt összekapcsolási utasításokat, mások csak a SELECT-WHERE szakaszban fogadják el:

Összekapcsolás a SELECT-FROM-ban:

SELECT *
FROM Beteg KEY JOIN Lelet

Összekapcsolás a WHERE-ben:

SELECT *
FROM Beteg, Lelet
WHERE Beteg.ID = Lelet.BetegID

[szerkesztés] Keresés

Bizonyos SQL kiszolgálók gyors keresésnél csak a teljesen pontosan beírt keresőkérdésre találják meg a választ. Gondot kell fordítanunk a kis- és nagybetűkre, valamint az ékezetek helyes használatára (Oracle, Firebird, PostgresSQL).

Más SQL kiszolgálók képesek figyelmen kívül hagyni az ékezeteket és egyenrangúnak tekintik a kis- és nagybetűket a keresés során, ha ezt kérjük (Sybase ASE, Sybase ASA).

[szerkesztés] FROM nélküli SELECT

FROM nélküli SELECT utasításra példa:

SELECT SYSDATE

A fenti példa egyes SQL kiszolgálók esetében nem működik, mivel a FROM náluk kötelező nyelvi elem.

Ezért például az Oracle minden adatbázisában szerepelteti a DUAL táblát, amelynek egyetlen rekordja van. Így Oracle SQL-ben ezt kell írnunk:

SELECT SYSDATE FROM DUAL

Természetesen itt a DUAL tábla valódi tartalma lényegtelen.

Bármely adatbankban, ha számolási eredményekre kíváncsi a felhasználó, lehetséges egy dummy (vagy tetszőleges nevű) üres tábla létrehozása, majd ennek felhasználásaval aritmetikai műveletek végezhetők el. Példa:

 create table dummy (teszt numeric)
 insert into dummy values(0)
 select (12+88)/3 from dummy
Főbb programozási nyelvek (továbbiak) +/-

Kereskedelmi: ABAP | Ada | Awk | C | C++ | C# | COBOL | Delphi | Fortran | Java | JavaScript | Lisp | Objective-C | Perl | PHP | PL/SQL | Python | SAS | sh | SQL | Visual Basic

Oktatási: Eiffel | Haskell | Logo | SML | Pascal | Prolog | Scheme | Smalltalk

Történelmi: ALGOL | APL | BASIC | Clipper | MUMPS | PL/I | Simula

Személyes eszközök