☰ 4. osztály - Számítástechnika és informatika

4. osztály - Számítástechnika és informatika

1. Adatbázisok - Elmélet

3. SQL


SQL bevezető

SQL egy szabványos programnyelv mely biztosítja az adatbázishoz a hozzáférést és kezelését.


Mi az SQL?

  • SQL a Structured Query Language rövidítése
  • SQL lehetővé teszi az adatbázishoz a hozzáférést és kezelését
  • SQL ANSI (American National Standards Institute) szabvány

Mit lehet megtenni az SQL-el?

  • SQL adatbázisokat tud létrehozni
  • SQL adatbázisokat tud törölni
  • SQL az adatbázisban új táblákat tud létrehozni
  • SQL az adatbázisban táblákat tud letörölni
  • SQL az adatbázisba táblájábnan új rekorodokat tud hozzáadni
  • SQL az adatbázis táblájából rekordokat tud törölni
  • SQL az adatbázist rendszerezni tudja
  • SQL az adatbázis iránt lekéréseket tud végrehajtani
  • SQL az adatbázisból adatokat tud kapni
  • SQL az adatbázisba beépített procedurákat tud létrehozni
  • SQL az adatbázisban nézeteket tud létrehozni
  • SQL az adatbázisban a hozzáférési jogokat tudja szabályozni a táblákhoz, procedurákhoz és nézetekhez

SQL szabvány mégis....

Annak ellenére hogy az SQL ANSI (American National Standards Institute) szabvány, különböző SQL változatok léteznek.

Hogy mégis be legyen tartva a szabvány, az összes változat a fő utasításokat (mint SELECT, UPDATE, DELETE, INSERT, WHERE) hasonló módon támogatja.


Az SQL alkalmazása a web oldalon

Egy web oldal kidoldozásához mely az adatbázis adatait képes kimutatni szükségesek a következők:

  • Adatbáziskezelő program (RDBMS mint MS Access, SQL Server, MySQL)
  • A server oldalon végrehajtandó skript-ek mint PHP vagy ASP
  • SQL alkalmazaása a kívánt adatok lekéréséhez
  • HTML/CSS alkalmazása

RDBMS

RDBMS a Relational Database Management System rövidítése (relációs adatbázis kezelő rendszer).

RDBMS az SQL alapja és minden korszerű adatbázisrendszerhez mint MS SQL Server, IBM DB2, Oracle, MySQL vagy Microsoft Access.

Az adatok a RDBMS rendszerben tábla nevű objektumokban vannak tárolva.

A tábla relációs adathalmaz és oszlopokból és sorokból áll.



SQL helyesírás

A leggyakoribb műveletek melyek az adatbázison végrehajtódnak az SQL utasítások által történnak.


Megjegyezni...

Az SQL nem tesz különbséget a kis és nagy betűk között: a select ugyanaz mint a SELECT. Az áttekintés végett ajánlott a kulcsszavakat nagy betűkkel írni.


Pontosvessző az SQL utasítás végén?

Egyes adatbáziskezelők megkövetelik a pontosvesszőt minden SQL utasítás végén.

A pontosvessző szabványos módja az SQL utasítások szétválasztására az adatbázisokban melyek engedélyezik a több SQL utasítás végrehajtását egy server hozzáférés idelye alatt. Ajánlott a pontosvessző használata minden SQL utasítás végén.


Néhány legfontosabb SQL utasítás

UtasításMagyarázat
SELECTadatok választása az adatbázisból
UPDATEaz adatok rendszerezése
DELETEadatok törlése az adatbázisból
INSERT INTOúj adat bevitele
CREATE DATABASEadatbázis létrehozása
ALTER DATABASEadatbázis módosítása
CREATE TABLEtáblázat létrehozása
ALTER TABLEtáblázat módosítása
DROP TABLEtáblázat törlése
CREATE INDEXindex létrehozása
DROP INDEXindex törlése



SQL SELECT utasítás

SELECT *
FROM table_name;

vagy

SELECT column_name,column_name
FROM table_name;

A SELECT utasításal a result set-ben megjelenő mezőket (oszlopokat) definiálják. Amennyiben a csillag van megadva a SELECT után, akkor minden mező (oszlop) ki lessz listázva. Amennyiben nem szükséges minden oszlop megjelenítése, a szükséges mezőket (oszlopokat) a SELECT után kell felsorolni vesszővel elválasztva egymástól.


SQL SELECT utasítás

SELECT column_name, column_name
FROM table_name;

Amennyiben nem szükséges minden oszlop megjelenítése, a szükséges oszlopokat a SELECT után kell felsorolni vesszővel elválasztva egymástól.


SQL SELECT DISTINCT utasítás

SELECT DISTINCT column_name, column_name
FROM table_name;

A SELECT utasításhoz tartozó DISTINCT segítségével a listázás csak a különböző adatokat fogja kimutatni a megadott oszlopban (oszlopokban). A megadott oszlopban (oszlopokban) található adatok nem fognak ismétlődni.



SQL WHERE utasítás

SELECT column_name, column_name
FROM table_name
WHERE column_name operator value;

A WHERE utasítás a kiválasztást szűkíti csak azokra a rekordokra melyek a megadott feltételnek tesznek eleget. A megadott oszlopban lévő adatok meg kell hogy feleljenek a megadott feltételnek. Például ha a "Price" oszlopban számértékek szerepelnek, a "Name" oszlopban meg szöveg, akkor a lehetséges feltételek igy nézhetnének ki:
WHERE Price > 18
Amennyiben szöveget tartalmazó mezőről van szó az operátor utáni érték idézőjelben kell hogy legyen:
WHERE Name = "Steve"

A megengedett operátorok:

OperátorMagyarázat
=Egyenlő
< >Különbözik
>Nagyobb mint
<Kisebb mint
>=Nagyobb vagy egyenlő
<=Kisebb vagy egyenlő
BETWEENA megadott értékek között
LIKEMint
INTartalmazza


SQL WHERE operátorok AND és OR

Az AND és OR operátorok lehetővé teszik a kiválasztás szűkítését több mint egy feltétel megadásával.

Az AND operátor megjeleníti a rekordot amennyiben mindkét feltétel pontos.

SELECT column_name, column_name
FROM table_name
WHERE column_name operator value AND
      column_name operator value;

Az OR operátor megjeleníti a rekordot amennyiben legalább egy feltétel pontos.

SELECT column_name, column_name
FROM table_name
WHERE column_name operator value OR
      column_name operator value;

Az AND és OR operátorokat sokféleképpen lehet kombinálni zárójelekkel. A zárójelek szerepe hasonló a számtani műveleteknél alkalmazottaknak.

SELECT column_name, column_name
FROM table_name
WHERE column_name operator value OR
     (column_name operator value AND
      column_name operator value);



SQL ORDER BY utasítás

SELECT column_name, column_name
FROM table_name
ORDER BY column_name ASC|DESC, column_name ASC|DESC;

Az ORDER BY utasítás az SQL által megkapott eredménytáblázat sorbarakását biztosítja. Az alapértelmezett sorrend a számoknál növekvő sorrend a szövegnél meg az ábécé. A megengedett sorrend szabályzó kulcsszavak az ASC (növekvő) és DESC (csökkenő) sorrend.



SQL INSERT INTO utasítás

Az INSERT INTO utasítás segítségével adatbevitelt lehet elvégezni. Az utasításnak két formája létezik:

INSERT INTO table_name
VALUES (value1, value2, value3, ...);

vagy

INSERT INTO table_name (column1, column2, column3, ...)
VALUES (value1, value2, value3, ...);

Az első formában nincsennak megadva az oszlopok (mezők) melyekbe az értékek bevitele történik.



SQL UPDATE utasítás

Az UPDATE utasítás a tábla adatainak a módosítására szolgál.

UPDATE table_name
SET column1 = value1, column2 = value2, ...
WHERE some_column = some_value;

Oda kell figyelni a WHERE kulcsszóra a SQL UPDATE kifejezésben!
A WHERE kulcsszó adja meg hogy melyik rekord vagy rekordok lesznek megváltoztatva.
Amennyiben a WHERE kulcsszó kimarad, mindegyik rekord a táblában módosítva lessz!



SQL DELETE utasítás

A DELETE utasítás a rekordokat töröl a táblából.

DELETE FROM table_name
WHERE some_column = some_value;

Oda kell figyelni a WHERE kulcsszóra a SQL DELETE kifejezésben!
A WHERE kulcsszó adja meg hogy melyik rekord vagy rekordok lesznek kitörölve.
Amennyiben a WHERE kulcsszó kimarad, mindegyik rekord a táblában törölve lessz!



SQL SELECT TOP utasítás

A SELECT TOP utasítás a recordok száma megadására szolgál, melyek a lekérés eredményeként fognak megjelenni. Ez az utasítás hasznos lehet amennyiben nagy táblákban kell lekéréseket írni. A sok record beolvasása kihatásal tud lenni a rendszer teljesítményére.

A SELECT TOP utasítást nem támogatja mindegyik adatbáziskezelő rendszer.

SQL Server/MS Access példa:

SELECT TOP number|percent column_name(s)
FROM table_name;

MySQL példa:

SELECT column_name(s)
FROM table_name
LIMIT number;

Oracle példa:

SELECT column_name(s)
FROM table_name
WHERE ROWNUM <= number;



SQL LIKE operátor

A LIKE operátort a WHERE utasításnál alkalmazzák a megadott karaktersorozat keresésére.

SELECT column_name(s)
FROM table_name
WHERE column_name LIKE pattern;

A pattern a karaktersorozat melyben leggyakrabban joker jelek vannak.



SQL dzsókerok

Dzsókerok az SQL-ben a LIKE operátorral eggyütt használják hogy bármelyik karaktert helyettesítsék a stringekben keresés közben.

A dzsókerok az SQL-ben a:

DzsókerMagyarázat
%nulla vagy több karaktert helyettesít
_egy karaktert helyettesít
[karakterlista]A keresett karakterek listája
[^karakterlista]
vagy
[!karakterlista]		 karakterek listája
melyek NEM találhatóak
a rekordokban

A % dzsóker használata

SELECT *
FROM table_name
WHERE column_name LIKE 'srb%';

Minden rekord megtalálása melynek 'srb' a kezdete.

SELECT *
FROM table_name
WHERE column_name LIKE '%ija';

Minden rekord megtalálása melynek 'ija' a vége.

SELECT *
FROM table_name
WHERE column_name LIKE '%rbi%';

Minden rekord megtalálása melynek 'rbi' a közepe.

A _ dzsóker használata

SELECT *
FROM table_name
WHERE column_name LIKE '_rbija';

Minden rekord megtalálása melynek bármi az első karaktere és 'rbija' a vége.

SELECT *
FROM table_name
WHERE column_name LIKE 's_b_j_';

Minden rekord megtalálása melynek 's' a kezdete, utánna bármilyen karakter, utánna 'b' karakter, utánna bármilyen karakter, következő karakter a 'j' és utánna bármilyen karakter.

A [karakterlista] dzsóker alkalmazása

SELECT *
FROM table_name
WHERE column_name LIKE '[bsp]%';

Minden rekord megtalálása melynek az első karaktere 'b', 's' vagy 'p', a végződése meg bármilyen karaktersorozat.

SELECT *
FROM table_name
WHERE column_name LIKE '[a-c]%';

Minden rekord megtalálása melynek az első karaktere 'a', 'b' vagy 'c', a végződése meg bármilyen karaktersorozat.

SELECT *
FROM table_name
WHERE column_name NOT LIKE '[bsp]%';

Minden rekord megtalálása melynek NEM az első karaktere 'b', 's' vagy 'p', a végződése meg bármilyen karaktersorozat.



SQL IN operátor

Az IN operátor lehetővé teszi a több érték megadását a WHERE feltételben.

SELECT column_name(s)
FROM table_name
WHERE column_name IN (value1,value2,...);



SQL BETWEEN operátor

A BETWEEN operátor lehetővé teszi a határértékek megadását, melyek között kell megtalálni az eredményt. Az értékek lehetnek számok, betűk és dátumok.

SELECT column_name(s)
FROM table_name
WHERE column_name BETWEEN value1 AND value2;

A következő példában ki lesz választva az összes termék melynek az ára 10 és 20 közott van.

SELECT *
FROM products
WHERE Price BETWEEN 10 AND 20;

A következő példában ki lesz választva az összes termék melynek az ára NEM 10 és 20 közott van.

SELECT *
FROM products
WHERE Price NOT BETWEEN 10 AND 20;



SQL aliászok

Az aliászok arra szolgálnak hogy ideiglenesen más néven lehessen hívni a táblát vagy mezőt (oszlopot). Az aliászok segítségével a táblák vagy mezők (oszlopok) nevei rövidebbek, olvashatóbbak.

SQL aliász helyesírása oszlopra:

SELECT column_name AS alias_name
FROM table_name;

SQL aliász helyesírása táblára:

SELECT column_name(s)
FROM table_name AS alias_name;

Oszlopokra vonatkozó alász példák

A következő példában az SQL lekérésben két aliász lesz megadva, az egyik a column_name_1 a második column_name_2. Dupla idézőjel vagy szögletes zárójelet kell használni amennyiben üres hely van az elnevezésben.

SELECT col_1 AS alias1, col_2 AS [alias 2]
FROM table_name;

A következő példában az SQL lekérésben több oszlop van kombinálva, az értékei vesszőkkel lesznek elválasztva.

SELECT col_1, col_2+ ', ' +col_3+ ', ' +col_4+ ', ' +col_5 AS Address
FROM table_name;

MySQL bázis esetében:

SELECT col_1, CONCAT(col_2, ', ', col_3, ', ', col_4, ', ', col_5) AS Address
FROM table_name;

Táblákra vonatkozó alász példa

A következő lekérésben az aliászok egy betüre rövidítik a tábla nevét, és egyben a lekérést is.

SELECT o.col_1, o.col_2, c.col_1
FROM table_1 AS c, table_2 AS o
WHERE c.col_1="value_1" AND c.col_0 = o.col_0;

Ugyanaz a lekérés aliász nélkül:

SELECT table_2.col_1, table_2.col_2, table_1.col_1
FROM table_1, table_2
WHERE table_1.col_1="value_1" AND table_1.col_0 = table_2.col_0;

Az aliászok hasznosak lehetnek a következő esetekben:

  • amennyiben több mint egy tábla szerepel a lekérésben
  • amennyiben a lekérésben fügvények vannak használva
  • amennyiben az oszlopok nevei hosszúak és olvashatatlanok
  • amennyiben kettö vagy több oszlopot kell kombinálni


SQL JOIN

SQL JOIN lehetővé teszi kettő vagy több tábla sorainak az egyesítését. Az egyesítés alapja a közös sorokon alapszik melyek a táblákban találhatók.

A leggyakrabb egyesítés fajtája az SQL INNER JOIN (simple join) egyszerű egyesítés. Az SQL INNER JOIN kimutatja az összes sort több táblából melyekben a join feltétel ki van elégítve.

PÉLDA:

Az Orders tábla

OrderID CustomerID OrderDate
10308 2 1996-09-18
10309 37 1996-09-19
10310 77 1996-09-20

A Customers tábla

CustomerID CustomerName ContactName Country
1 Alfreds Futterkiste Maria Anders Germany
2 Ana Trujillo Emparedados y helados Ana Trujillo Mexico
3 Antonio Moreno Taquería Antonio Moreno Mexico

Észrevehető hogy a "CustomerID" mező az "Orders" táblában utal a "CustomerID" mezőre a "Customers" táblában. A két tábla között a reláció a "CustomerID" mező. A következő lekérés (mely INNER JOIN-t tartalmaz) lesz végrehajtva:

SELECT Orders.OrderID, Customers.CustomerName, Orders.OrderDate
FROM Orders
INNER JOIN Customers
ON Orders.CustomerID = Customers.CustomerID;

Az eredmény:

OrderID CustomerName OrderDate
10308 Ana Trujillo Emparedados y helados 1996-09-18

Ugyanazt az eredményt adja a következő lekérés is:

SELECT Orders.OrderID, Customers.CustomerName, Orders.OrderDate
FROM Customers
INNER JOIN Orders
ON Customers.CustomerID = Orders.CustomerID;

Különböző JOIN típusok léteznek

  • INNER JOIN kimutatja az összes sort amennyiben létezik legalább egy megegyezés MINDKÉT táblában
  • LEFT JOIN kimutatja az összes sort a bal táblából és a sorokat melyek megegyeznek a jobb táblában
  • RIGHT JOIN kimutatja az összes sort a jobb táblából és a sorokat melyek megegyeznek a bal táblában
  • FULL JOIN kimutatja az összes sort amennyiben létezik legalább egy megegyezés az EGYIK táblában


SQL INNER JOIN

SQL INNER JOIN és a JOIN megegyeznek.

Az INNER JOIN kulcsszó közös értékek alapján, melyek mindkét táblában megjelennek, sorokat választ mindkét táblából.

SELECT column_name(s)
FROM table1
INNER JOIN table2
ON table1.column_name = table2.column_name;

vagy

SELECT column_name(s)
FROM table1
JOIN table2
ON table1.column_name = table2.column_name;

inner join



SQL LEFT JOIN

Az SQL LEFT JOIN kimutatja sz öszes sort a bal táblából (table1), a megfelelő sorokkal a jobb táblából (table2). Az eredmény NULL a jobb oldalon ha nincs megegyezés.

SELECT column_name(s)
FROM table1
LEFT JOIN table2
ON table1.column_name = table2.column_name;

vagy

SELECT column_name(s)
FROM table1
LEFT OUTER JOIN table2
ON table1.column_name = table2.column_name;

Egyes adatbáziskezelőknél a LEFT JOIN elnevezése LEFT OUTER JOIN.

inner join

PÉLDA:

Az Orders tábla

OrderID CustomerID OrderDate
10308 2 1996-09-18
10309 37 1996-09-19
10310 77 1996-09-20
10311 2 1996-09-21

A Customers tábla

CustomerID CustomerName ContactName Country
1 Alfreds Futterkiste Maria Anders Germany
2 Ana Trujillo Emparedados y helados Ana Trujillo Mexico
3 Antonio Moreno Taquería Antonio Moreno Mexico

Amennyiben a következő lekérés lesz végrehajtva:

SELECT Customers.CustomersName, Orders.OrderID
FROM Customers
LEFT JOIN Orders
ON Customers.CustomerID = Orders.CustomerID
ORDER BY Customers.CustomerName;

Megjelenik az öszes CustomersName a Customers táblából és azok akiknek rendelésük van, megjelenik a rendelés száma. Amennyiben egy vevőnek több rendelése van, az ő neve ismétlődik többször is, minden megrendelésszámnál:

CustomerName OrderID
Alfreds Futterkiste
Ana Trujillo Emparedados y helados 10308
Ana Trujillo Emparedados y helados 10311
Antonio Moreno Taquería



SQL RIGHT JOIN

Az SQL RIGHT JOIN kimutatja sz öszes sort a jobb táblából (table2), a megfelelő sorokkal a bal táblából (table1). Az eredmény NULL a bal oldalon ha nincs megegyezés.

SELECT column_name(s)
FROM table1
RIGHT JOIN table2
ON table1.column_name = table2.column_name;

vagy

SELECT column_name(s)
FROM table1
RIGHT OUTER JOIN table2
ON table1.column_name = table2.column_name;

Egyes adatbáziskezelőknél a RIGHT JOIN elnevezése RIGHT OUTER JOIN.

inner join

PÉLDA:

Az Orders tábla

OrderID CustomerID EmloyeeID OrderDate ShipperID
10308 2 3 1996-09-18 3
10309 37 2 1996-09-19 1
10310 77 3 1996-09-20 2

Az Employees tábla

EmployeeID LastName FirstName BirthDate Photo
1 Davolio Nancy 12/8/1968 EmpID1.pic
2 Fuller Andrew 2/19/1952 EmpID2.pic
3 Leverling Janet 8/30/1963 EmpID3.pic

Amennyiben a következő lekérés lesz végrehajtva:

SELECT Orders.OrderID, Employees.FirstName
FROM Orders
RIGHT JOIN Employees
ON Orders.EmployeeID = Employees.EmployeeID
ORDER BY Orders.OrderID;

A jobb táblából (Employees) mindegyik sor meg lesz jelenítve még ha nincs is megegyezés a bal táblával:

OrderID FirstName
Nancy
10308 Janet
10309 Andrew
10310 Janet



SQL FULL JOIN

Az SQL FULL JOIN kimutatja az öszes sort mindkét táblázatból. A FULL OUTER JOIN összegzi a LEFT és RIGHT JOIN eredményeit.

SELECT column_name(s)
FROM table1
FULL OUTER JOIN table2
ON table1.column_name = table2.column_name;

inner join

PÉLDA:

A Customers tábla

CustomerID CustomerName ContactName Country
1 Alfreds Futterkiste Maria Anders Germany
2 Ana Trujillo Emparedados y helados Ana Trujillo Mexico
3 Antonio Moreno Taquería Antonio Moreno Mexico

A Orders tábla

OrderID CustomerID OrderDate
10308 2 1996-09-18
10309 37 1996-09-19
10310 77 1996-09-20

Amennyiben a következő lekérés lesz végrehajtva:

SELECT Customers.CustomerName, Orders.OrderID
FROM Customers
FULL OUTER JOIN Orders
ON Customers.CustomerID = Orders.CustomerID
ORDER BY Customers.CustomerName;

Mindkét tábla sor megjelenik, megegyezés nélkül is.

CustomerName OrderID
Alfreds Futterkiste
Ana Trujillo Emparedados y helados 10308
Antonio Moreno Taquería
10309
10310



SQL UNION

SQL UNION összegzi a két vagy több SELECT utasítás eredményét. Minden SELECT utasításnak az UNION-on belül egyforma számú oszlopa kell hogy legyen. Az oszlopok tipusa és száma is azonos kell hogy legyen.

SELECT column_name(s) FROM table1
UNION
SELECT column_name(s) FROM table2;

Az UNION operátor alapértelmezetten különböző értékeket választ. Az egyforma értékek kimutatásához az ALL kulcsszót is alkalmazni kell.

SELECT column_name(s) FROM table1
UNION ALL
SELECT column_name(s) FROM table2;

Az oszlopok elnevezése az UNION result szett-ben leggyakrabban megegyeznek az első SELECT utasításéval.


SQL UNION példa

A Customers tábla

CustomerID CustomerName ContactName City Country
1 Alfreds Futterkiste Maria Anders Berlin Germany
2 Ana Trujillo Emparedados y helados Ana Trujillo México D.F. Mexico
3 Antonio Moreno Taquería Antonio Moreno México D.F. Mexico

A Suppliers tábla

SupplierID SupplierName ContactName City Country
1 Exotic Liquid Charlotte Cooper London UK
2 New Orleans Cajun Delights Shelley Burke New Orleans USA
3 Grandma Kelly's Homestead Regina Murphy Ann Arbor USA

Amennyiben a következő lekérés lesz végrehajtva:

SELECT City FROM Customers
UNION
SELECT City FROM Suppliers
ORDER BY City;

Az eredmény (az UNION csak a különböző értékeket mutatja):

City
Ann Arbor
Berlin
London
México D.F.
New Orleans

SQL UNION ALL példa

A Customers tábla

CustomerID CustomerName ContactName City Country
1 Alfreds Futterkiste Maria Anders Berlin Germany
2 Ana Trujillo Emparedados y helados Ana Trujillo México D.F. Mexico
3 Antonio Moreno Taquería Antonio Moreno México D.F. Mexico

A Suppliers tábla

SupplierID SupplierName ContactName City Country
1 Exotic Liquid Charlotte Cooper London UK
2 New Orleans Cajun Delights Shelley Burke New Orleans USA
3 Grandma Kelly's Homestead Regina Murphy Ann Arbor USA

Amennyiben a következő lekérés lesz végrehajtva:

SELECT City FROM Customers
UNION ALL
SELECT City FROM Suppliers
ORDER BY City;

Az eredmény (UNION ALL kimutatja az ismétlődő értékeket is):

City
Ann Arbor
Berlin
London
México D.F.
México D.F.
New Orleans

SQL UNION ALL és a WHERE

A Customers tábla

CustomerID CustomerName ContactName City Country
1 Alfreds Futterkiste Maria Anders Berlin Germany
2 Ana Trujillo Emparedados y helados Ana Trujillo México D.F. Mexico
3 Antonio Moreno Taquería Antonio Moreno México D.F. Mexico

A Suppliers tábla

SupplierID SupplierName ContactName City Country
1 Exotic Liquid Charlotte Cooper London UK
2 New Orleans Cajun Delights Shelley Burke New Orleans USA
3 Grandma Kelly's Homestead Regina Murphy Ann Arbor USA

Amennyiben a következő lekérés lesz végrehajtva:

SELECT City, Country FROM Customers
WHERE Country = "Mexico"
UNION ALL
SELECT City, Country FROM Suppliers
WHERE Country = "USA"
ORDER BY City;

Az eredmény (UNION ALL kimutatja az ismétlődő értékeket is):

City Country
Ann Arbor USA
México D.F. Mexico
México D.F. Mexico
New Orleans USA



SQL SELECT INTO

Az SQL segítségével lehetséges az adatok másolása egyik táblából a másikba.

A SQL SELECT INTO utasítás csak a kiválasztott adatokat másolja új táblába.

Mindegyik oszlop másolása az új táblába:

SELECT *
INTO newtable [IN externaldb]
FROM table1;

A kiválasztott oszlopok másolása az új táblába:

SELECT column_name(s)
INTO newtable [IN externaldb]
FROM table1;

Az új tábla a SELECT kifejezésben megadott oszlopnevekkel és adattipusokkal jön létre. Új oszlopneveket is lehet megadni az AS alkalmazásával.

PÉLDÁK

A Customers tábla tartalékmásolat létrehozása:

SELECT *
INTO CustomersBackup2013
FROM Customers;

Az IN kulcsszó használatával a tábla másolása egy másik adatbázisba:

SELECT *
INTO CustomersBackup2013 IN 'Backup.mdb'
FROM Customers;

Csak az egyes oszlopok másolása az új táblába:

SELECT CustomerName, ContactName
INTO CustomersBackup2013
FROM Customers;

Csak a Német vevők másolása az új táblába:

SELECT *
INTO CustomersBackup2013
FROM Customers
WHERE Country = 'Germany';

Több táblából származó adatok másolása az új táblába:

SELECT Customers.CustomerName, Orders.OrderID
INTO CustomersOrderBackup2013
FROM Customers
LEFT JOIN Orders
ON Customers.CustomerID = Orders.CustomerID;

A SELECT INTO kifejezés felhasználható új, üres tábla létrehozására amely egy másik tábla beállításain alapszik. A WHERE feltételt úgy kell megadni hogy ne adjon adatokat:

SELECT *
INTO newtable
FROM table1
WHERE 1=0;



SQL INSERT INTO SELECT

Az SQL segítségével lehet adatokat másolni egy táblából másik, létező táblába.

A SQL INSERT INTO SELECT utasítás csak a kiválasztott adatokat másolja a másik táblába. A meglévő adatok a céltáblában változatlanok maradnak.

Az összes oszlop másolása egy táblából, a másik, meglévő táblába:

INSERT INTO table2
SELECT *
FROM table1;

A kiválasztott oszlopok másolása egyik táblából a másik, meglévő táblába:

INSERT INTO table2
(column_name(s))
SELECT column_name(s)
FROM table1;

A Customers tábla

CustomerID CustomerName ContactName City Country
1 Alfreds Futterkiste Maria Anders Berlin Germany
2 Ana Trujillo Emparedados y helados Ana Trujillo México D.F. Mexico
3 Antonio Moreno Taquería Antonio Moreno México D.F. Mexico

A Suppliers tábla

SupplierID SupplierName ContactName City Country
1 Exotic Liquid Charlotte Cooper London UK
2 New Orleans Cajun Delights Shelley Burke New Orleans USA
3 Grandma Kelly's Homestead Regina Murphy Ann Arbor USA

Csak egyes oszlopok másolása a "Suppliers" táblából a "Customers" táblába:

INSERT INTO Customers (CustomerName, Country)
SELECT SupplierName, Country
FROM Suppliers

A Customers tábla a lekérés után így néz ki:

CustomerID CustomerName ContactName City Country
Exotic Liquid UK
New Orleans Cajun Delights USA
Grandma Kelly's Homestead USA
1 Alfreds Futterkiste Maria Anders Berlin Germany
2 Ana Trujillo Emparedados y helados Ana Trujillo México D.F. Mexico
3 Antonio Moreno Taquería Antonio Moreno México D.F. Mexico

Csak a USA-beli beszerzők másolása a "Suppliers" táblából a "Customers" táblába:

INSERT INTO Customers (CustomerName, Country)
SELECT SupplierName, Country
FROM Suppliers
WHERE Country='USA';

A Customers tábla a lekérés után így néz ki:

CustomerID CustomerName ContactName City Country
New Orleans Cajun Delights USA
Grandma Kelly's Homestead USA
1 Alfreds Futterkiste Maria Anders Berlin Germany
2 Ana Trujillo Emparedados y helados Ana Trujillo México D.F. Mexico
3 Antonio Moreno Taquería Antonio Moreno México D.F. Mexico



SQL CREATE DATABASE

A CREATE DATABASE kifejezés az adatbázis létrehozására szolgál.

Adatbázis létrehozása:

CREATE DATABASE dbname;

A "my_db" nevű adatbázis létrehozása:

CREATE DATABASE my_db;



SQL CREATE TABLE

A CREATE TABLE kifejezés tábla létrehozására szolgál.

A táblák sorokból és oszlopokból állnak. A táblának neve kell hogy legyen.

Tábla létrehozása:

CREATE TABLE table_name
(
column_name1 data_type(size),
column_name2 data_type(size),
column_name3 data_type(size),
...
);

A column_name paraméter megadja az oszlop nevét.

A data_type paraméter megadja az oszlop adattípusát (például varchar, integer, decimal, date, stb.).

A size paraméter megadja az oszlop méretét.

PÉLDA

"Persons" nevű tábla létrehozása mely öt oszlopból áll: PersonID, LastName, FirstName, Address i City.

A kifejezés így néz ki:

CREATE TABLE Persons
(
PersonID int,
LastName varchar(255),
FirstName varchar(255),
Address varchar(255),
City varchar(255)
);

A PersonID oszlop int típusú és integereket fog tartalmazni.

A LastName, FirstName, Address és City oszlopok varchar típusúak, karaktereket fognak tartalmazni melyekben legtöbb 255 karakter lehet.

Az üres "Persons" tábla így néz ki:

PersonID LastName FirstName Address City
.

Az üres táblát adatokkal fel lehet tölteni az INSERT INTO kifejezés használatával.




SQL CONSTRAINTS

SQL constraints (korlátozások) alkalmazása az adatokra vonatkozó szabályok megadásánál található. Amennyiben megszegés létezik a constraint (kolátozás) és az adatok feletti művelet között, a constrain (korlátozás) megszakítja a műveletet. A constraints (korlátozások) megadhatók a tábla létrehozáskor (a CREATE TABLE utasításban) vagy a megévő táblában (ALTER TABLE utasítás keretein belül).

CREATE TABLE table_name
(
column_name1 data_type(size) constraint_name,
column_name2 data_type(size) constraint_name,
column_name3 data_type(size) constraint_name,
....
);

Az SQL-ben a következő constraintok (korlátozások) léteznek:

Constraint Opis
NOT NULL Az oszlopban nem lehet NULL érték
UNIQUE Mindegyik sornak a táblában egyedi értéke kell hogy legyen
PRIMARY KEY A NOT NULL és UNIQUE vegyülete. Biztosítja hogy az oszlop (illetve kettö vagy több oszlop kombinációja) egyedi legyen, az adat gyorsabb és könyebb megtalálása céljából
FOREIGN KEY Biztosítja az adatok referenciális integritását, az egyik táblában lévő adat megfelelő értéke a másik táblában
CHECK Biztosítja az hogy az oszlop adatai különos feltételenek feleljenek meg
DEFAULT Az oszlop alapéertelmezett értéke



SQL NOT NULL constraint

Alapértelmezetten a tábla oszlopa tartalmazhat null értéket. NOT NULL constraint (korlátozás) nem engedélyezi az oszlopba a NULL beírását. NOT NULL kényszeríti a mezőt hogy vegyen fel valami értéket. Ezek szerint nem lehet új recordot beírni vagy a recordot frissíteni adat hozzárendelés nélkül ebben a mezőben. A következő SQL kényszeríti a "P_Id" és a "LastName" oszlopokat hogy ne vegyék fel a NULL értéket:

CREATE TABLE PersonsNotNull
(
P_Id int NOT NULL,
LastName varchar(255) NOT NULL,
FirstName varchar(255),
Address varchar(255),
City varchar(255)
);



SQL UNIQUE constraint

Az UNIQUE constraint egyedülállóan atonosít minden recordot az adatbázis táblájában. UNIQUE és PRIMARY KEY constraintek biztosítják az oszlop vagy oszlopcsoport egyediségét. A PRIMARY KEY constraint automatikusan tartalmazza a megadott UNIQUE constraintot is. Egy táblában több UNIQUE constraint is lehetséges, de csak egy PRIMARY KEY.

SQL UNIQUE constraint és a CREATE TABLE

Az UNIQUE constraint létrehozása a "P_Id" oszlopon a tábla létrehozásánál a "Persons" táblában:

SQL Server / Oracle / MS Access:

CREATE TABLE Persons
(
P_Id int NOT NULL UNIQUE,
LastName varchar(255) NOT NULL,
FirstName varchar(255),
Address varchar(255),
City varchar(255)
);

MySQL:

CREATE TABLE Persons
(
P_Id int NOT NULL,
LastName varchar(255) NOT NULL,
FirstName varchar(255),
Address varchar(255),
City varchar(255),
UNIQUE (P_Id)
);

Az UNIQUE constraint elnevezése engedélyezéséhez és a név mehghatározásához amely több oszlopra vonatkozik a következő SQL-t kell használni:

MySQL / SQL Server / Oracle / MS Access

CREATE TABLE Persons
(
P_Id int NOT NULL,
LastName varchar(255) NOT NULL,
FirstName varchar(255),
Address varchar(255),
City varchar(255),
CONSTRAINT uc_PersonID UNIQUE (P_Id,LastName)
);

SQL UNIQUE constraint és az ALTER TABLE

Az UNIQUE constraint létrehozása a "P_Id" oszlopon amikor a tábla már létezik, a következő SQL-t kell alkalmazni:

MySQL / SQL Server / Oracle / MS Access

ALTER TABLE Persons
ADD UNIQUE (P_Id);

Az UNIQUE constraint elnevezése engedélyezéséhez és a név mehghatározásához amely több oszlopra vonatkozik a következő SQL-t kell használni:

MySQL / SQL Server / Oracle / MS Access

ALTER TABLE Persons
ADD CONSTRAINT uc_PersonID UNIQUE (P_Id,LastName);

DROP (A UNIQUE constraint-nak az eltávolítása)

A UNIQUE constraint eltávolításához a következő SQL-t kell alkalmazni:

MySQL:

ALTER TABLE Persons
DROP INDEX uc_PersonID;

SQL Server / Oracle / MS Access:

ALTER TABLE Persons
DROP CONSTRAINT uc_PersonID;



SQL PRIMARY KEY constraint

A PRIMARY KEY constraint egyedülállóan atonosít minden recordot az adatbázis táblájában. A primáris kulcs egyedi értékeket kell hogy tartalmazzon. A "primary key" oszlop nem tartalmazhat NULL értéket. A táblákban többnyire kell hogy legyen primáris kulcs, a táblának csak egy primáris kulcsa lehet.

SQL PRIMARY KEY constraint és a CREATE TABLE

A "Persons" tábla létrehozásával létrejön a PRIMARY KEY a "P_Id" oszlopon:

MySQL:

CREATE TABLE Persons
(
P_Id int NOT NULL,
LastName varchar(255) NOT NULL,
FirstName varchar(255),
Address varchar(255),
City varchar(255),
PRIMARY KEY (P_Id)
);

SQL Server / Oracle / MS Access:

CREATE TABLE Persons
(
P_Id int NOT NULL PRIMARY KEY,
LastName varchar(255) NOT NULL,
FirstName varchar(255),
Address varchar(255),
City varchar(255)
);

Az PRIMARY KEY constraint elnevezése engedélyezéséhez és a PRIMARY KEY constraint mehghatározásához amely több oszlopra vonatkozik a következő SQL-t kell használni:

MySQL / SQL Server / Oracle / MS Access:

CREATE TABLE Persons
(
P_Id int NOT NULL,
LastName varchar(255) NOT NULL,
FirstName varchar(255),
Address varchar(255),
City varchar(255),
CONSTRAINT pk_PersonID PRIMARY KEY (P_Id, LastName)
);

MEGJEGYZÉS:
A felső példában csak egy primáris kulcs van (pl_PersonID). A primáris kulcs értéke két oszlopból áll (P_Id és LastName).

SQL PRIMARY KEY és az ALTER TABLE

A PRIMARY KEY constraint létrehozásához a "P_Id" oszlopon, amikor a tábla már létezik, a következő SQL-t kell alkalmazni:

MySQL / SQL Server / Oracle / MS Access:

ALTER TABLE Persons
ADD PRIMARY KEY (P_Id);

Az PRIMARY KEY constraint elnevezése engedélyezéséhez és a PRIMARY KEY constraint mehghatározásához amely több oszlopra vonatkozik a következő SQL-t kell használni:

MySQL / SQL Server / Oracle / MS Access:

ALTER TABLE Persons
ADD CONSTRAINT pk_PersonID PRIMARY KEY (P_Id, LastName);

MEGJEGYZÉS:
Amennyiben az ALTER TABLE van használva hogy a primáris kulcs hozzá legyen adva a táblához, a primáris kulcs oszlop előzőleg úgy kell hogy legyen definiálva hogy ne tartalmazzon NULL értéket.

DROP (a PRIMARY KEY constraint eltávolítása)

A PRIMARY KEY constraint eltávolítására a következő SQL-t kell alkalmazni:

MySQL:

ALTER TABLE Persons
DROP PRIMARY KEY;

SQL Server / Oracle / MS Access:

ALTER TABLE Persons
DROP CONSTRAINT pk_PersonID;



SQL FOREIGN KEY constraint

FOREIGN KEY az egyik táblában utal a PRIMARY KEY-re a másik táblában.

A külső kulcs (foreign key) magyarázata:

A "Persons" tábla:

P_Id LastName FirstName Address City
1 Hansen Ola Timotevin 10 Sandnes
2 Svendson Tove Borgvn 23 Sandnes
3 Pettersen Kari Storgt 20 Stavanger

A "Orders" tábla:

O_Id OrderNo P_Id
1 77895 3
2 44678 3
3 22456 2
4 24562 1

Észrevehető hogy a "P_Id" oszlop az "Orders" táblában utal a "P_Id" oszlopra a "Persons" táblában.

A "P_Id" oszlop a "Persons" táblában PRIMARY KEY (primáris kulcs).

A "P_Id" oszlop az "Orders" táblában FOREIGN KEY (külső kulcs).

A FOREIGN KEY constraintet használják hogy megakadályozza a műveleteket melyek megsemmisítenék a kapcsolatot a táblák között.

A FOREIGN KEY constraint megakadályozza a nemérvényes értékek bevitelét a külső kulcs oszlopba, mivel ezek az értékek meg kell hogy egyezzenek az értékekkel melyek a másik táblában vannak melyre utal a külső kulcs.

SQL FOREIGN KEY és a CREATE TABLE

A következő SQL létrehozza a FOREIGN KEY-t a "P_Id" oszlopon az "Orders" tábla létrehozásakor:

MySQL:

CREATE TABLE Orders
(
O_Id int NOT NULL,
OrderNo int NOT NULL,
P_Id int,
PRIMARY KEY (O_Id),
FOREIGN KEY (P_Id) REFERENCES Persons(P_Id)
);

SQL Server / Oracle / MS Access:

CREATE TABLE Orders
(
O_Id int NOT NULL PRIMARY KEY,
OrderNo int NOT NULL,
P_Id int FOREIGN KEY REFERENCES Persons(P_Id)
);

Az FOREIGN KEY constraint elnevezése engedélyezéséhez és a FOREIGN KEY constraint mehghatározásához amely több oszlopra vonatkozik a következő SQL-t kell használni:

MySQL / SQL Server / Oracle / MS Access:

CREATE TABLE Orders
(
O_Id int NOT NULL,
OrderNo int NOT NULL,
P_Id int,
PRIMARY KEY (O_Id),
CONSTRAINT fk_PerOrders FOREIGN KEY (P_Id)
REFERENCES Persons(P_Id)
);

SQL FOREIGN KEY és az ALTER TABLE

A következő SQL létrehozza a FOREIGN KEY-t a "P_Id" oszlopon amennyiben az "Orders" tábla már létezik, a következő SQL-t kell alkalmazni:

MySQL / SQL Server / Oracle / MS Access:

ALTER TABLE Orders
ADD FOREIGN KEY (P_Id)
REFERENCES Persons(P_Id);

Az FOREIGN KEY constraint elnevezése engedélyezéséhez és a FOREIGN KEY constraint mehghatározásához amely több oszlopra vonatkozik a következő SQL-t kell használni:

MySQL / SQL Server / Oracle / MS Access:

ALTER TABLE Orders
ADD CONSTRAINT fk_PerOrders
FOREIGN KEY (P_Id)
REFERENCES Persons(P_Id);

DROP (FOREIGN KEY constraint eltávolítása)

A FOREIGN KEY constraint eltávolításához a következő SQL-t kell alkalmazni:

MySQL:

ALTER TABLE Orders
DROP FOREIGN KEY fk_PerOrders;

SQL Server / Oracle / MS Access:

ALTER TABLE Orders
DROP CONSTRAINT fk_PerOrders;



SQL CHECK constraint

A CHECK constraint korlátozza az értékeket melyeket az oszlopban megjelenhetnek. Az oszlopra vonatkozó CHECK constraint csak az adott oszlopra vonatkozik. A CHECK constraintet táblára is lehet megadni.

SQL CHECK és a CREATE TABLE

A következő SQL létrehozza a CHECK constraintet a "P_Id" oszlopon a "Persons" tábla létrehozásánál. A CHECK constraint megadja hogy a "P_Id" oszlop tartalmazhat csak egész számokat (integereket) melyek nagyobbak nullától :

MySQL:

CREATE TABLE Persons
(
P_Id int NOT NULL,
LastName varchar(255) NOT NULL,
FirstName varchar(255),
Address varchar(255),
City varchar(255),
CHECK (P_Id>0)
);

SQL Server / Oracle / MS Access:

CREATE TABLE Persons
(
P_Id int NOT NULL CHECK (P_Id>0),
LastName varchar(255) NOT NULL,
FirstName varchar(255),
Address varchar(255),
City varchar(255)
);

A CHECK constraint elnevezése engedélyezéséhez és a név mehghatározásához amely több oszlopra vonatkozik a következő SQL-t kell használni:

MySQL / SQL Server / Oracle / MS Access

CREATE TABLE Persons
(
P_Id int NOT NULL,
LastName varchar(255) NOT NULL,
FirstName varchar(255),
Address varchar(255),
City varchar(255),
CONSTRAINT chk_Person CHECK (P_Id>0 AND City='Sandnes')
);

SQL CHECK és az ALTER TABLE

Az CHECK constraint létrehozása a "P_Id" oszlopon amikor a tábla már létezik, a következő SQL-t kell alkalmazni:

MySQL / SQL Server / Oracle / MS Access

ALTER TABLE Persons
ADD CHECK (P_Id>0);

A CHECK constraint elnevezése engedélyezéséhez és a név mehghatározásához amely több oszlopra vonatkozik a következő SQL-t kell használni:

MySQL / SQL Server / Oracle / MS Access

ALTER TABLE Persons
ADD CONSTRAINT chk_Person CHECK (P_Id>0 AND City='Sandnes');

DROP (CHECK constraint eltávolítása)

A CHECK constraint eltávolításához a következő SQL alkalmazható:

MySQL:

ALTER TABLE Persons
DROP CHECK chk_Person;

SQL Server / Oracle / MS Access:

ALTER TABLE Persons
DROP CONSTRAINT chk_Person;



SQL DEFAULT constraint

A DEFAULT constraint az oszlop alapértelmezett értékének bevitelére szolgál. Az alapértelmezett érték beírása az új record megnyitásánál történik, amennyiben nincs más érték megadva.

SQL DEFAULT és a CREATE TABLE

A következő SQL létrehozza a DEFAULT constraint a "City" oszlopon a "Persons" tábla létrehozásánál:

My SQL / SQL Server / Oracle / MS Access:

CREATE TABLE Persons
(
P_Id int NOT NULL,
LastName varchar(255) NOT NULL,
FirstName varchar(255),
Address varchar(255),
City varchar(255) DEFAULT 'Sandnes'
);

A DEFAULT constraintet alkalmazni lehet a rendszerértékek bevitelére fügvények alkalmazásaával, mint például a GETDATE() fügvény:

CREATE TABLE Orders
(
O_Id int NOT NULL,
OrderNo int NOT NULL,
P_Id int,
OrderDate date DEFAULT GETDATE()
);

SQL DEFAULT és a ALTER TABLE

Az CHECK constraint létrehozása a "City" oszlopon amikor a tábla már létezik, a következő SQL-t kell alkalmazni:

upotrebiti naredni SQL:

My SQL:

ALTER TABLE Persons
ALTER City SET DEFAULT 'SANDNES';

SQL Server / MS Access:

ALTER TABLE Persons
ALTER COLUMN City SET DEFAULT 'SANDNES';

Oracle:

ALTER TABLE Persons
MODIFY City DEFAULT 'SANDNES';

DROP (DEFAULT constraint eltávolítása)

A DEFAULT constraint eltávolításához a következő SQL alkalmazható:

MySQL:

ALTER TABLE Persons
ALTER City DROP DEFAULT;

SQL Server / Oracle / MS Access:

ALTER TABLE Persons
ALTER COLUMN City DROP DEFAULT;



SQL CREATE index

A CREATE INDEX utasítás az indexeket hozza létre a táblákban. Az indexek biztosítják a gyors adatkeresést annélkül hogy az egész táblát ki kellene olvasni.

Indexek

Az indexeket létre kell hozni az adatok gyorsabb megtalálás céljából. A felhasználó nem látja az indexet, csak használja a gyorsabb adat keresés és gyorsabb lekérés végrehajtás céljábol.

MEGJEGYZÉS:
Az indexekkel ellátott táblák frissítése tovább tart mint a tábláké melyeknek nincsen indexük (mivel az indexeket is frissíteni kell). Ennél az oknál fogva csak azokon az oszlopokon (táblákon) melyeken gyakran lessz keresés végezve, hoznak létre indexeket.

SQL CREATE INDEX helyesrás

Index létrehozása a táblában. Duplikált értékek engedélyezettek:

CREATE INDEX index_name
ON table_name (column_name);

SQL CREATE UNIQUE INDEX helyesírás

UNIQUE index létrehozása a táblában. Duplikált értékek nem engedélyezettek:

CREATE UNIQUE INDEX index_name
ON table_name (column_name);

MEGJEGYZÉS:
A helyesírás az indexek létrehozására különböznek a különböző adatbáziskezelő programoknál. Ellenőrizni kell a helyesírást az indexek létrehozása előtt.

CREATE INDEX példa

A következő SQL nyilatkozat létrehozza a "PIndex" indexet a "LastName" oszlopban mely a "Persons" táblában van:

CREATE INDEX PIndex
ON Persons (LastName);

Amennyiben az indexet több oszlop kombinációján kellene létrehozni, az oszlopokat zárójelben kell felsorolni vesszőkkel elválasztva:

CREATE INDEX PIndex
ON Persons (LastName, FirstName);



SQL DROP

Indexeket, táblákat és adatbázisokat könnyen lehet törölni/eltávolítani DROP nyilatkozat alkalmazásával.


SQL DROP INDEX

A DROP INDEX nyilatkozat törli az indexet a táblából.

DROP INDEX helyesírás a MySQL-ben:

ALTER TABLE table_name DROP INDEX index_name;

DROP INDEX helyesírás a MS Access-ben:

DROP INDEX index_name ON table_name;

DROP INDEX helyesírás a MS SQL Server-ben:

DROP INDEX table_name.index_name;

DROP INDEX helyesíás a DB2/Oracle-ban:

DROP INDEX index_name;


SQL DROP TABLE

A DROP TABLE nyilatkozat törli a táblát.

DROP TABLE table_name;


SQL DROP DATABASE

A DROP DATABASE nyilatkozat törli az adatbázist.

DROP DATABASE database_name;


SQL TRUNCATE TABLE

Amennyiben csak az adatokat kell kitörölni a táblából, a TRUNCATE TABLE nyilatkozatot kell használni.

TRUNCATE TABLE table_name;



SQL ALTER TABLE

Az ALTER TABLE utasítás az oszlopok hozzáadására, törlésére vagy változtatására szolgál a meglévő táblában.

Az oszlop hozzáadására a következő kifejezés szolgál:

ALTER TABLE table_name
ADD column_name datatype;

Az oszlopok törlésére a következő kifejezés szolgál (egyes báziskezelők nem engedélyezik ezt a műveletet):

ALTER TABLE table_name
DROP COLUMN column_name;

Az oszlop adattipus változtatására a következő kifejezés szolgál:

SQL Server / MS Access:

ALTER TABLE table_name
ALTER COLUMN column_name datatype;

My SQL / Oracle (10G változat előtt):

ALTER TABLE table_name
MODIFY COLUMN column_name datatype;

Oracle 10G és későbbi változatok:

ALTER TABLE table_name
MODIFY column_name datatype;


SQL ALTER TABLE példa

A "Persons" tábla:

P_Id LastName FirstName Address City
1 Hansen Ola Timoteivn 10 Sandnes
2 Svendson Tove Borgvn 23 Sandnes
3 Pettersen Kari Storgt 20 Stavanger

A "Persons" táblát ki kellene bővíteni a "DateOfBirth" nevű oszloppal. A következő kifejezést kell alkalmazni:

ALTER TABLE table_name
ADD DateOfBirth date;

Az új oszlop "DateOfBirth" dátum típusú és csak dátum típusú adatokat fog tartalmazni. A "datatype" adja meg az adatípust melyet az oszlop tartalmazni fog:

A "Persons" tábla most így néz ki:

P_Id LastName FirstName Address City DateOfBirth
1 Hansen Ola Timoteivn 10 Sandnes
2 Svendson Tove Borgvn 23 Sandnes
3 Pettersen Kari Storgt 20 Stavanger

Adattípus változtatáas példa

A "DateOfBirth" oszlopban a "Persons" táblában az adattípust meg kellene változtatni.

A következő kifejezést kell alkalmazni:

ALTER TABLE table_name
ALTER COLUMN DateOfBirth year;

Most a "DateOfBirth" oszlop year típusú adat és az évet két illetve négy számjegyű számként fogja őrizni.

DROP COLUMN példa

Most a "DateOfBirth" oszlopot a "Persons" táblából ki kellene törölni.

A következő kifejezést kell alkalmazni:

ALTER TABLE table_name
DROP COLUMN DateOfBirth;

A "Persons" tábla most így néz ki:

P_Id LastName FirstName Address City
1 Hansen Ola Timoteivn 10 Sandnes
2 Svendson Tove Borgvn 23 Sandnes
3 Pettersen Kari Storgt 20 Stavanger



SQL AUTO INCREMENT field

Az autoincrement lehetővé teszi az egyedi számok létrehozását az új record hozzáadásánál a táblába.

Gyakori az igény a primáris kulcs létrehozására az új recordok hozzáadása alkalmával.

A MySQL helyesírás

A következő SQL utasítás definiálja hogy az "ID" oszlop legyen autoincrement és primáris kulcs a "Persons" táblában:

CREATE TABLE Persons
(
ID int NOT NULL AUTO_INCREMENT,
LastName varchar(255) NOT NULL,
FirstName varchar(255),
Address varchar(255),
City varchar(255),
PRIMARY KEY (ID)
);

A MySQL az AUTO_INCREMENT kulcszavat használja hogy létrehozza az autoincrement tulajdonságot.

Az alapértelmezett kezdőértéke az AUTO_INCREMENT-nek 1 és egyesével növekszik minden új recordal.

Az AUTO_INCREMENT szekvencia beindítása másik kezdőértékkel a következő SQL utasítással történik:

ALTER TABLE Persons
AUTO_INCREMENT=100

Az új record hozzáadásához a "Persons" táblában NEM kell megadni az "ID" oszlop értékét (az egyedi érték automatikusan lesz hozzáadva):

INSERT INTO Persons (FirstName,LastName)
VALUES ('Lars','Monsen');

A felső SQL utasítás új recordot ad hozzá a "Persons" táblába. Az "ID" oszlopnak a seq_person sekvencia következő értéke lesz hozzárendelve. A "FirstName" oszlopnak a "Lars" érték lesz hozzárendelve, amíg a "LastName" oszlopnak a "Monsen" érték lesz hozzárendelve.

Az SQL Server helyesírás

A következő SQL utasítás definiálja hogy az "ID" oszlop legyen autoincrement és primáris kulcs a "Persons" táblában:

CREATE TABLE Persons
(
ID int IDENTITY(1,1) PRIMARY KEY,
LastName varchar(255) NOT NULL,
FirstName varchar(255),
Address varchar(255),
City varchar(255)
);

Az MS SQL az IDENTITY kulcsszót használja hogy autoincrement tulajdonságot hozzon létre. A felső példában az IDENTITY kezdő értéke 1 és egyesével növekszik minden új record hozzáadásánál. Ahhoz hogy az "ID" oszlop kezdőértéke 10 legyen és ötössével növekedjen a következőt kell megváltoztatni: IDENTITY(10,5). Az új record hozzáadásánál a "Persons" táblában NEM kell megadni az "ID" oszlop értékét (az egyedi érték automatikusan lesz hozzáadva):

INSERT INTO Persons (FirstName,LastName)
VALUES ('Lars','Monsen');

A felső SQL utasítás új recordot ad hozzá a "Persons" táblába. Az "ID" oszlopnak a seq_person sekvencia következő értéke lesz hozzárendelve. A "FirstName" oszlopnak a "Lars" érték lesz hozzárendelve, amíg a "LastName" oszlopnak a "Monsen" érték lesz hozzárendelve.

Az Access helyesírás

A következő SQL utasítás definiálja hogy az "ID" oszlop legyen autoincrement és primáris kulcs a "Persons" táblában:

CREATE TABLE Persons
(
CREATE TABLE Persons
(
ID Integer PRIMARY KEY AUTOINCREMENT,
LastName varchar(255) NOT NULL,
FirstName varchar(255),
Address varchar(255),
City varchar(255)
);

A MS Access az AUTOINCREMENT kulcsszót használja az autoincrement tulajdonsághoz. Az alapértelmezett kezdőértéke az AUTO_INCREMENT-nek 1 és egyesével növekszik minden új record hozzáadásánál. Ahhoz hogy az "ID" oszlop kezdőértéke 10 legyen és ötössével növekedjen a következőt kell megváltoztatni: AUTOINCREMENT(10,5).

Az új record hozzáadásánál a "Persons" táblában nem NEM kell megadni az "ID" oszlop értékét (az egyedi érték automatikusan lesz hozzáadva).

INSERT INTO Persons (FirstName,LastName)
VALUES ('Lars','Monsen');

A felső SQL utasítás új recordot ad hozzá a "Persons" táblába. Az "ID" oszlopnak a seq_person sekvencia következő értéke lesz hozzárendelve. A "FirstName" oszlopnak a "Lars" érték lesz hozzárendelve, amíg a "LastName" oszlopnak a "Monsen" érték lesz hozzárendelve.

Az Oracle helyesírás

Az Oracle kód különbözik valamennyire a többitől.

Szükséges létrehozni az autoincrement mezőt szekvenciális objektummal (ez az objektum létrehozza a numerikus szekvenciát).

A CREATE SEQUENCE szintakszist kell alkalmazni:

CREATE SEQUENCE seq_person
MINVALUE 1
START WITH 1
INCREMENT BY 1
CACHE 10

A felső kód létrehozza a seq_person szekvenciát mely az egyesel kezdődik és egyesével növekszik. Ugyanakkor kesselni fog 10 értéket ebből a tulajdonságból. A Cache opció megadja hány érték legyen megőrizve a memóriába, a gyorsabb hozzáférés miatt.

Az új record beviteléhez a "Persons" táblába szükséges alkalmazni a nextval fügvényt (ez a fügvény visszaadja a seq_person következő értékét):

INSERT INTO Persons (ID,FirstName,LastName)
VALUES (seq_person.nextval,'Lars','Monsen');

A felső SQL utasítás új recordot ad hozzá a "Persons" táblába. Az "ID" oszlopnak a seq_person sekvencia következő értéke lesz hozzárendelve. A "FirstName" oszlopnak a "Lars" érték lesz hozzárendelve, amíg a "LastName" oszlopnak a "Monsen" érték lesz hozzárendelve.



SQL views

Az SQL-ben a view virtuális tábla mely az SQL utasítás result szettjén van alapozva. A view oszlopokat és sorokat tartalmaz mint az igazi tábla. A mezők a view-ben egy vagy több valódi táblából származnak. Hozzáadhatók SQL WHERE és JOIN fügvények hogy adatok legyenek kimutatva, amennyiben az adatok egy táblából származnak.

SQL view helyesírás

CREATE VIEW view_name AS
SELECT column_name(s)
FROM table_name
WHERE condition;

MEGJEGYZÉS:
A view mindig pontos adatokat mutatnak. A database engine minden view lekérés alkalmával újból létrehozza az adatokat, újból alkalmazva az SQL view kifejezést.

SQL CREATE VIEW példák

A "Current Product List" view mutatja az aktív termékeket (a termékek melyek gyártása nem lett abbahagyva) a "Products" táblából. A view a következő SQL segítségével lett létrehozva:

CREATE VIEW [Current Product List] AS
SELECT ProductID, ProductName
FROM Products
WHERE Discontinued = No;

A view kimutatására a lekérés:

SELECT *
FROM [Current Product List];

A következő view a "Products" táblából az átlagnál feletti árakkal rendelkező termékeket válassza ki:

CREATE VIEW [Products Above Average Price] AS
SELECT ProductName, UnitPrice
FROM Products
WHERE UnitPrice > (SELECT AVG(UnitPrice) FROM Products);

A view kimutatására a lekérés:

SELECT *
FROM [Products Above Average Price];

A következő view az összesített eladást számolja ki minden kategóriára 1997-ből. Eészre lehet venni hogy ez a view a "Product Sales for 1997" view-ből válassza ki az adatokat:

CREATE VIEW [Category Sales For 1997] AS
SELECT DISTINCT CategoryName, Sum(ProductSales) AS CategorySales
FROM [Product Sales for 1997]
GROUP BY CategoryName;

A view kimutatására a lekérés:

SELECT *
FROM [Category Sales For 1997];

Lehetséges a feltételek hozzáadása a lekérésekhez. Lehetséges csak a "Beverages" kategória összesített eladását kimutatni:

SELECT *
FROM [Category Sales For 1997]
WHERE CategoryName = 'Beverages';

SQL view frisstés

A view frissítését a következő utasítással lehet elvégezni:

CREATE OR REPLACE VIEW view_name AS
SELECT column_name(s)
FROM table_name
WHERE condition;

Amennyiben szükséges a "Current Product List" view-hez hozzáadni a "Category" oszlopot, ezt a műveletet következő SQL utasítasal lehet elvégezni:

CREATE OR REPLACE VIEW [Current Product List] AS
SELECT ProductID, ProductName, Category
FROM Products
WHERE Discontinued = No;

SQL view megsemmisítése

A view törlését a DROP VIEW utasítással lehet elvégezni:

DROP VIEW view_name;



SQL date functions

SQL dates (dátumok)

A legösszetettebb része a dátumkezelésnek az adatok bevitele, melynél a dátum formátuma meg kell hogy eggyezzen a dátum formátummal mely az adatbázis oszlopában található.

Amennyiben az adat csak dátumot tartalmaz, a lekérések az elvárások szerint dolgoznak. Amennyiben az idő is hozzá van adva a dátumhoz a dolgok valamivel bónyolultabbak lesznek.

MySQL date fügvények

A következő táblázatban vannak felsorolva a legfontosabb date fügvények a MySQL-ben:

Fügvény Leírás
NOW() A jelen dátum és időt adja
CURDATE() A jelen dátumot adja
CURTIME() A jelen időt adja
DATE() A dátumot válassza ki a dátum vagy dátum/idő kifejezésből
EXTRACT() A dátum/idő részét adja
DATE_ADD() A megadott intervallumot hozzáadja a dátumhoz
DATE_SUB() A megadott intervallumot kivonja a dátumból
DATEDIFF() A két dátumközötti különbséget adja napokban kifejezve
DATE_FORMAT() A dátum/idő adatot mutatja különböző formátumokban

SQL Server Date fügvények

A következő táblázatban a legfontosabb SQL Server dátumfügvényei vannak felsorolva:

Fügvény Leírás
GETDATE() A jelen dátum és időt adja
DATEPART() A dátum/idő részét adja
DATEADD() A megadott intervallumot hozzáadja vagy kivonja a dátumból
DATEDIFF() A két dátumközötti időt adja
CONVERT() A dátum/idő adatot mutatja különböző formátumokban

SQL Date adattípusok

A MySQL a következő adattípusokat tartalmazza a dátum vagy dátum/idő értékek számára:

  • DATE - formátum: YYYY-MM-DD
  • DATETIME - formátum: YYYY-MM-DD HH:MI:SS
  • TIMESTAMP - formátum: YYYY-MM-DD HH:MI:SS
  • YEAR - formátum: YYYY ili YY

Az SQL Server a következő adattípusokat tartalmazza a dátum vagy dátum/idő értékek számára:

  • DATE - formátum YYYY-MM-DD
  • DATETIME - formátum: YYYY-MM-DD HH:MI:SS
  • SMALLDATETIME - formátum: YYYY-MM-DD HH:MI:SS
  • TIMESTAMP - formátum: jedinstveni broj

SQL dátumkezelés

A két dátumot egyszerű osszehasonlítani amennyiben nincs jelen a dátum komponens.

Amennyiben az "Orders" tábla így néz ki:

OrderID ProductName OrderDate
1 Geitost 2008-11-11
2 Camembert Pierrot 2008-11-09
3 Mozzarella di Giovanni 2008-11-11
4 Mascarpone Fabioli 2008-10-29

Ki kellene választani a recordokat melyeknek az OrderDate megegyezik a "2008-11-11" dátummal.

A következő SELECT utasítást kell alkalmazni:

SELECT *
FROM Orders
WHERE OrderDate='2008-11-11';

A result set így fog kinézni:

OrderID ProductName OrderDate
1 Geitost 2008-11-11
3 Mozzarella di Giovanni 2008-11-11

Amennyiben az "Orders" tábla így néz ki (felfigyelni az időkomponensre az "OrderDate" oszlopban):

OrderID ProductName OrderDate
1 Geitost 2008-11-11 13:23:44
2 Camembert Pierrot 2008-11-09 15:45:21
3 Mozzarella di Giovanni 2008-11-11 11:12:01
4 Mascarpone Fabioli 2008-10-29 14:56:59

Amennyiben ugyanaz a SELECT kifejezés lesz itt is alkalmazva mint a felső példában:

SELECT *
FROM Orders
WHERE OrderDate='2008-11-11';

A lekérés nem fog adni eredményt. A lekérés csak azokat az adatokat keresi melyek időkomponens nélkül vannak.

Javaslat: Amennyiben a lekérések egyszerűek kellene hogy legyenek, ki kell hagyni az időkomponenst.



SQL NULL értékek

A NULL értékek képviselik a hiányzó vagy ismeretlen értékeket. Alapértelmezetten az oszlopok tartalmazhatnak NULL értékeket.

Amennyiben az oszlop a táblában opcionális lehetséges a recordot bevinni vagy frissteni a meglévő recordot, az érték megadás nélkül abban az oszlopban. Ez esetben a mező NULL értékkel lesz lemetve.

A NULL értékek másképpan vannak kezelve mit a többi érték.

A NULL a hely mely tárolja az ismeretlen vagy alkalmazhatatlan értékeket.

MEGJEGYZÉS:
Lehetetlen a NULL és 0 összehasonlítása mivel e két érték nem ekvivalens.

SQL a NULL értékek alkalmazása

Amennyiben a "Persons" tábla így néz ki:

P_Id LastName FirstName Address City
1 Hansen Ola Sandnes
2 Svenson Tove Borgvn 23 Sandnes
3 Petterson Kari Stavanger

Feltételezett hogy az "Address" oszlop a "Persons" táblában opcionális. Amennyiben egy rekord hozzáadása történik úgy hogy az "Address" oszlopban az érték kimarad, az "Address" oszlop NULL értékkel lesz lementve.

Lehetetlen ellenőrizni a NULL értékeket összehasonlítás operátorokkal mint =, <, > vagy <>.

Szükséges alkalmazni az "IS NULL" és az "IS NOT NULL" operátorokat.


SQL IS NULL

A NULL értékeket tartalmazó recordok kiválasztásához az "Address" oszlopban szükséges alkalmazni az IS NULL operátort.

SELECT LastName, FirstName, Address
FROM Persons
WHERE Address IS NULL

A result set a következőképpen fog kinézni:

LastName FirstName Address
Hansen Ola
Petterson Kari


SQL IS NOT NULL

A NULL nélküli recordok kiválasztásához a kifejezés a következő:

SELECT LastName, FirstName, Address
FROM Persons
WHERE Address IS NOT NULL

A result set a következőképpen fog kinézni:

LastName FirstName Address
Svendson Tove Borgvn 23


SQL NULL fügvények ISNULL(), NVL(), IFNULL() és COALESCE()

Amennyiben a "Products" tábla így néz ki:

P_Id ProductName UnitPrice UnitsInStock UnitsOnOrder
1 Jarlsberg 10.45 16 15
2 Mascarpone 32.56 23
3 Gorgonzola 15.67 9 20

Továbbá feltételezhető hogy az "UnitsOnOrder" oszlop opcionális és tartalmazhat NULL értékeket.

A következő SELECT kifejezés van használva:

SELECT ProductName, UnitPrice * (UnitsInStock + UnitsOnOrder)
FROM Products

A felső példában amennyiben bármelyik "UnitsOnOrder" értéke NULL, a kifejezés értéke NULL lessz.

A Microsoft ISNULL() fügvény alkalmazató a NULL értékek kezelés megadására.

NVL(), IFNULL() és COALESCE() fügvények alkalmazásával ugyanazt az eredményt lehet elérni.

Ebben a példában a NULL éertékeket nullaként kellene kezelni.

Léjebb, amennyiben az "UnitsOnOrder" értéke NULL nem fog ártani a számításnak mivel az ISNULL() fügvény nullát ad vissza ha az érték NULL:

MS Access

SELECT ProductName, UnitPrice*(UnitsInStock+IF(ISNULL(UnitsOnOrder),0,UnitsOnOrder))
FROM Products

SQL Server

SELECT ProductName,UnitPrice*(UnitsInStock+ISNULL(UnitsOnOrder,0))
FROM Products

Oracle

Az Oracle nem tartalmaz ISNULL() fügvényt. A NVL() fügvény segítségével ugyanaz az eredmény:

SELECT ProductName,UnitPrice*(UnitsInStock+NVL(UnitsOnOrder,0))
FROM Products

MySQL

MySQL tartalmaz ISNULL() fügvényt. Valamivel különbözik a Microsoft ISNULL() fügvénytől. A MySQL-ben lehet az IFNULL() fügvényt ilyen módon alkalmazni:

SELECT ProductName,UnitPrice*(UnitsInStock+IFNULL(UnitsOnOrder,0))
FROM Products

vagy lehet alkalmazni a COALESCE() fügvényt a következőképpen:

SELECT ProductName,UnitPrice*(UnitsInStock+COALESCE(UnitsOnOrder,0))
FROM Products



SQL általános adattípusok

Az adattípus megadja milyen értékeket tárolhat az oszlop.

Minden oszlopnak az adatbázis táblájában meg kell hogy legyen adva a neve és az adattípusa.

Az SQL fejlesztők meg kell hogy határozzák milyen típusú adatok lesznek tárolva az adatbázis minden táblájában és oszlopában még amikor az SQL tábla létrejön.

A következő táblázat mutatja az általános adattípusokat az SQL-ben:

Adattípus Leírás
CHARACTER(n) Karakterkből álló string, a megadott hosszúsága n
VARCHAR(n) ili CHARACTER VARYING(n) Karakterkből álló string, változó hosszúságú, a legnagyobb n
BINARY(n) Bináris string, a megasott hosszúsága n
BOOLEAN TRUE vagy FALSE értékeket tárol
VARBINARY(n) ili BINARY VARYING(n) Bináris string, változó hosszúságú, a legnagyobb n
INTEGER(p) Egész szám (tizedesek nélkül), a pontossága p
SMALLINT Egész szám (tizedesek nélkül), a pontossága 5
INTEGER Egész szám (tizedesek nélkül), a pontossága 10
BIGINT Egész szám (tizedesek nélkül), a pontossága 19
DECIMAL(p,s) Tizedes szám, p - az egész számjegyek száma, s - az tört rész számjegyek száma
NUMERIC(p,s) Tizedes szám, ugyanolyan mint az előző
FLOAT(p) Lebegőpontos számok megjelenítése, a szám alapja 10, p a manissza számjegyek száma
REAL Lebegőpontos szám, a manitissza ponotssága 7
FLOAT Lebegőpontos szám, a manitissza ponotssága 16
DOUBLE PRECISION Lebegőpontos szám, a manitissza ponotssága 16
DATE Az év, hónap és nap értékeit tárolja
TIME Az óra, perc és másodperc értékeit tárolja
TIMESTAMP Az év, hónap, nap, óra, perc és másodperc értékeit tárolja
INTERVAL Uređen skup celih brojeva koji predstavljaju period vremena, zavisno od tipa intervala
ARRAY Megadott hosszúságu rendezett elemek halmaza
MULTISET Változó hosszúságu rendezetlen elemek halmaza
XML XML adatokat tárol


SQL különböző adattípusok áttekintése

A különböző adatbázisok különböző választékú adattípusokat kínálnak fel.

A következő táblázat egyes változók áttekintését nyújtja más-más adatbázisokban:

Adattípus Access SQLServer Oracle MySQL PostgreSQL
boolean Yes/No Bit Byte N/A Boolean
integer Number
(integer)		 Int Number Int
Integer		 Int
Integer
float Number
(single)		 Float
Real		 Number Float Numeric
currency Currency Money N/A N/A Money
string (fixed) N/A Char Char Char Char
string (variable) Text (<256)
Memo (65k+)		 Varchar Varchar
Varchar2		 Varchar Varchar
binary object OLE Object Memo Binary (fixed up to 8K)
Varbinary (<8K)
Image (<2GB)		 Long Raw Blob Text Binary
Varbinary

Ugyanazoknak az adattípusoknak különböző nevei lehetnek a különböző adatbázisokban. Amennyiben az adattípus neve meg is egyezik, a méret vagy más részletek különbözhetnek! A dokumentációt szükséges megnézni!



SQL adattípusok a különböző adatbázisokban

Adattípusok és adattartományok a Microsoft Access, MySQL és SQL Server számára.


Microsoft Access adattípusok

Adattípus Leírás Tárhely
Text Karakterek (betűk, számok i jelek) a legnagyobb hossz 255.
Memo A memo a hosszab szövegeknél alkalmazzák. 65.536 karakterig tud tárolni. A memo mezőt nem lehet sorbarakni, keresni lehet benne.
Byte Egész számok 0 és 255 között. 1 byte
Integer Egész számok -32.768 és 32.767 között. 2 bytes
Long Egész számok -2.147.483.648 és 2.147.483.647 között. 4 bytes
Single Lebegőpontos szám. 4 bytes
Double Kétszeres pontosságú lebegőpontos szám. 8 bytes
Currency Pénzérték kimutatására szolgál. Az egésszám része 15 számjegyet tárolhat, amíg a tizedes rész 4 számot tárolhat. Lehetőség van a pénznem választására. 8 bytes
AutoNumber Az AutoNumber mező automatikusan hozzárendel számot minden recordnak. Általában 1-el kezdődik. 4 bytes
Date/Time Dátum és idő tárolására szolgál. 8 bytes
Yes/No A logikai mező kimutatható mint Yes/No, True/False vagy On/Off. A kódban a True és False állandók vannak használatban (ekvivalensek a -1 és 0 -val). Ebben a mezőben a NULL értékek tiltottak. 1 bit
Ole Object Tárolhat képeket, audió, videó, vagy más BLOB-okat (Binary Large OBjects). 1GB-ig
Hyperlink Linkeket tartalmaz más fájlok felé, web oldalakat i beleértve.
Lookup Wizard Engedélyezi a lehetőségek beírását, melyeket majd drop-down listából lehet választani. 4 bytes


MySQL adattípus

A MySQL-ben három fő adattípus létezik: Text, Number és Date/Time.


MySQL TEXT adattípus

Adattípus Leírás
CHAR(size) Megadott hosszúságu stringeket tárol (betűk, számok és jelek). A string hossza zárójelben van megadva. A string legnagyobb hossza 255 karakter.
VARCHAR(size) Változó hosszúságu stringeket tárol (betűk, számok és jelek). A string hossza zárójelben van megadva. A string legnagyobb hossza 255 karakter. Amennyiben több mint 255 karakter van bevíve, átvált TEXT típusra.
TINYTEXT Stringeket tárol. A string legnagyobb hossza 255 karakter.
TEXT Stringeket tárol. A string legnagyobb hossza 65.535 karakter.
MEDIUMTEXT Stringeket tárol. A string legnagyobb hossza 16.777.215 karakter.
LONGTEXT Stringeket tárol. A string legnagyobb hossza 4.294.967.295 karakter.
BLOB BLOB objektumokat tárol (Binary Large OBjects). A megengedett tárhely 65.535 bájt.
MEDIUMBLOB BLOB objektumokat tárol (Binary Large OBjects). A megengedett tárhely 16.777.215 bájt.
LONGBLOB BLOB objektumokat tárol (Binary Large OBjects). A megengedett tárhely 4.294.967.295 bájt.
ENUM(x,y,z,itd.) Lehetséges értékek listáját tárolja. Az enum lista legtöbb 65.535 értéket tárolhat. Amennyiben olyan érték van bevíve mely nem szerepel a listán üres érték lesz beillesztve. Az értékek beviteli sorrendben vannak felsorakoztatva. Az értékek bevitele a következő formátumban történik: ENUM('X','Y','Z')
SET Hasonló az ENUM-mal, a SET legtöbb 64 értéket tárolhat és több mint egy választást is tárolhat.

.


MySQL NUMBER adattípus

Adattípus Leírás
TINYINT(size) Egész számok -128 és 127 között. Az *UNSIGNED esetben 0 és 255 között. A számjegyeket meg lehet adni a zárójelben.
SMALLINT(size) Egész számok -32.768 és 32.767 között. Az *UNSIGNED esetben 0 és 65.535 között. A számjegyeket meg lehet adni a zárójelben.
MEDIUMINT(size) Egész számok -8.388.608 és 8.388.607 között. Az *UNSIGNED esetben 0 és 16.777.215 között. A számjegyeket meg lehet adni a zárójelben.
INT(size) Egész számok -2.147.483.648 és 2.147.483.647 között. Az *UNSIGNED esetben 0 és 4.294.967.295 között. A számjegyeket meg lehet adni a zárójelben.
BIGINT(size) Egész számok -9.223.372.036.854.775.808 és 9.223.372.036.854.775.807 között. Az *UNSIGNED esetben 0 és 18.446.744.073.709.551.615 között. A számjegyeket meg lehet adni a zárójelben.
FLOAT(size,d) Lebegőpontos szám. A számjegyek számát a size paraméterrel lehet megadni. A tizedes jel utáni számjegyek számát a d paraméterrel lehet megadni.
DOUBLE(size,d) Kétszeres pontosságú lebegőpontos szám. A számjegyek számát a size paraméterrel lehet megadni. A tizedes jel utáni számjegyek számát a d paraméterrel lehet megadni.
DECIMAL(size,d) A DOUBLE mint string tárolva, engedélyezett rögzített tizedesjel pozícióval. A számjegyek számát a size paraméterrel lehet megadni. A tizedes jel utáni számjegyek számát a d paraméterrel lehet megadni.

* Az INTEGER egy külön lehetőséggel van ellátva, a neve UNSIGNED. Általában az integer negatív értéktől kezdődik és a pozitív értékig van. Az UNSIGNED attribútum hozzáadásával ez a tartomány felfelé mozdul, nullától kezdődik és nem tartalmaz negatív számokat.


MySQL DATE adattípus

Adattípus Leírás
DATE() Dátum formátuma: YYYY-MM-DD. A támgtott időszak '1000-01-01' és '9999-12-31' között van.
DATETIME() * Dátum és idő kombinációja a formátuma: YYYY-MM-DD HH:MI:SS A támgtott időszak '1000-01-01 00:00:00' és '9999-12-31 23:59:59' között van.
TIMESTAMP() * Időpecsét. A TIMESTAMP értékei számokként vannak tárolva. A számok képviselik az eltelt másodperceket az Unix kezdetétől ('1970-01-01 00:00:00' UTC). A formátuma YYYY-MM-DD HH:MI:SS. A támgtott időszak '1970-01-01 00:00:01' UTC és '2038-01-09 03:14:07' UTC között van.
TIME() Idő, a formátuma: HH:MI:SS. A támgtott időszak '-838:59:59' és '838:59:59' között van.
YEAR() Az év két illetve négy számjegyű formátumban. A négyszámjegyű formátum támogatott időszaka 1901 és 2155 között van. A kétszámjegyű formátum támogatott időszaka 70 és 69 között van, képviselve az éveket 1970 és 2069 között.

* A DATETIME és a TIMESTAMP ugyanolyan formátumokban jelennek meg, közöttük nagy a különbség. Az INSERT vagy az UPDATE query elvégzésénél a TIMESTAMP atáll a jelen dátum és időpontra. A TIMESTAMP különböző formátumokat fogad el, mint: YYYYMMDDHHMISS, YYMMDDHHMISS, YYYYMMDD vagy YYMMDD.



SQL Server adattípusok

Az SQL Server négy alap adattípust tartalmaz: String, Number, Date/Time és töbi.


SQL Server STRING adattípus

Adattípus Leírás Tárhely
char(n) Megadott hosszúságu stringeket tárol (betűk, számok és jelek). A string hossza a zárójelben van megadva. A string legnagyobb hossza 8.000 karakter. megadott a hosszúsága.
varchar(n) Változó hosszúságu stringeket tárol (betűk, számok és jelek). A string hossza a zárójelben van megadva. A string legnagyobb hossza 8.000 karakter. 2 bájt + karakterszám
varchar(max) Változó hosszúságu stringeket tárol (betűk, számok és jelek). A string hossza a zárójelben van megadva. A string legnagyobb hossza 1.073.741.824 karakter. 2 bytes + broj karaktera
text Változó hosszúságu stringeket tárol (betűk, számok és jelek). A szöveges adat engedélyezett terjedelme 2GB. 4 bytes + broj karaktera
nchar Megadott hosszúságú Unicode string 4.000 karakterig. Zadata dužina x2
nvarchar Változó hosszúságu Unicode string 4.000 karakterig.
nvarchar(max) Változó hosszúságu Unicode string 536.870.912 karakterig.
ntext Változó hosszúságu Unicode string legnagyobb terjedelme 2GB.
bit Engedélyezve a 0, 1 vagy NULL.
binary(n) Megadott hosszúságú bináris string. Az engedélyezett méret 8.000 bájt.
varbinary Változó hosszúságú bináris string. Az engedélyezett méret 8.000 bájt.
varbinary(max) Megadott hosszúságú bináris string. Az engedélyezett méret 2GB.
image Megadott hosszúságú bináris string. Az engedélyezett méret 2GB.

.


SQL Server NUMBER adattípus

Adattípus Leírás Tárhely
tinyint Egész számokat tárol 0 és 255 között. 1 bájt
smallint Egész számokat tárol -32.768 és 32.767 között. 2 bájt
int Egész számokat tárol -2.147.483.648 és 2.147.483.647 között. 4 bájt
bigint Egész számokat tárol -9.223.372.036.854.775.808 és 9.223.372.036.854.775.807 között. 8 bájt
decimal(p,s) Számokat tárol -1038+1 és 1038–1 között. A p nevű paraméter megadja a számjegyek számát (a tizedes jel jobb és bal oldalán). A p értéke 1 és 38 között van. Az alapértelmezett értéke 18. Az s paraméter megadja a számjegyek számát a tizedes jel jobb oldalán. Az s értéke ö és p között kell hogy legyen. Az alapértelmezett értéke 0. 5-17 bájt
numeric(p,s) Számokat tárol -1038+1 és 1038–1 között. A p nevű paraméter megadja a számjegyek számát (a tizedes jel jobb és bal oldalán). A p értéke 1 és 38 között van. Az alapértelmezett értéke 18. Az s paraméter megadja a számjegyek számát a tizedes jel jobb oldalán. Az s értéke ö és p között kell hogy legyen. Az alapértelmezett értéke 0. 5-17 bájt
smallmoney Pénzadat -214.748,3648 és 214.748,3647 között. 4 bájt
money Pénzadat -922.337.203.685.477,5808 és 922.337.203.685.477,5807 között. 8 bájt
float(n) Lebegőpontos szám -1.79E+308 és 1.79E+308 között. Az n paraméter megadja hogy a mező 4 vagy 8 bájtot fog elfoglalni. Amennyiben a float(24) van megadva a szám 4 bájtot fog elfoglalni. Amennyiben a float(53) van megadva a szám 8 bájtot fog elfoglalni. Az alapértelmezett értéke az n-nek 53. 4 vagy 8 bájt
real Lebegőpontos szám -3.40E+38 és 3.40E+38 között. 4 bájt

.


SQL Server DATE adattípus

Adattípus Leírás Tárhely
datetime Dátum és időt tárol január 1. 1753 és december 31. 9999 között, 3,33 miliszekundumos pontossággal. 8 bájt
datetime2 Dátum és időt tárol január 1. 0001 és december 31. 9999 között, 100 nanoszekundumos pontossággal. 6-8 bájt
smalldatetime Dátum és időt tárol január 1. 1900 és június 6. 2079 között, 1 perces pontossággal. 4 bájt
date Dátumokat tárol január 1. 0001 és december 31. 9999 között. 3 bájt
time Időt tárol 100 nanoszekundumos pontossággal. 3-5 bájt
datetimeoffset Ugyanolyan mint a datetime2 bővített lehetőség az időzona beálltása. 8-10 bájt
timestamp Egyedi számot tárol mely felfrissül amikor a rekord létrejött vagy módosul. Az értéke az óra intervallumján alapszik és nem felel meg a valós időnek. Egy táblában csak egy timestamp típusú adat engedélyezett.

.


SQL Server többi adattípus

Adattípus Leírás
sql_variant Különböző adattípusokat tárol: text, ntext és timestamp kivételével. Az engedélyezett tárhely 8.000 bájt.
uniqueidentifier Adatokat tárol a globally unique identifier (GUID) identifikátorról.
xml XML adatformátumokat tárol. Az engedélyezett tárhely 2GB.
cursor Hivatkozásokat tárol a kurzorra melyek a későbbi adatbázis műveletekre kellenek.
table A result set-et tárolja a későbbi feldolgozás miatt.