SQL je standardni jezik za pristup i rukovanje bazama podataka.
Iako je SQL ANSI (American National Standards Institute) standard, postoje različite verzije SQL jezika.
Međutim da bude u skladu sa ANSI standardom, sve verzije podržavaju glavne komande (kao što su SELECT, UPDATE, DELETE, INSERT, WHERE) na sličan način.
Za pravljenje web stranice koja prikazuje podatke iz baze podataka, potrebno je sledeće:
RDBMS je skraćenica za Relational Database Management System (sistem za upravljanje relacionim bazama podataka).
RDBMS je osnova za SQL i za sve moderne baze podataka kao MS SQL Server, IBM DB2, Oracle, MySQL i Microsoft Access.
Podaci u RDBMS se skladište u objekte koji se zovu tabele.
Tabela je skup relacionih podataka i sastoji se od redova i kolona.
Najčešće akcije koje se vrše nad bazom podataka se vrše putem SQL iskaz.
SQL nije osetljiv na velika i mala slova: select je isto što i SELECT. Radi preglednosti poželjno je ključne reči pisati velikim slovima.
Pojedine baze podataka zahtevaju tačka-zarez na kraju svake SQL iskaza.
Tačka-zarez je standardan način da se razdvoje SQL iskazi u bazama podataka koji dozvoljavaju izvršenje više od jednog SQL iskaza u istom pozivu ka serveru. Preporuka je stavljati tačku-zarez na kraj svakog SQL iskaza.
Naredba | Objašnjenje |
---|---|
SELECT | izbor podatake iz baze |
UPDATE | ažuriranje podataka u bazi |
DELETE | brisanje podatka iz baze |
INSERT INTO | unos novog podatka u bazu |
CREATE DATABASE | kreiranje baze podataka |
ALTER DATABASE | modifikacija baze podataka |
CREATE TABLE | kreiranje nove tabele |
ALTER TABLE | modifikacija tabele |
DROP TABLE | brisanje tabele |
CREATE INDEX | kreiranje indeksa |
DROP INDEX | brisanje indeksa |
SELECT *
FROM table_name;
ili
SELECT column_name,column_name
FROM table_name;
Ključna reč SELECT vrši odabir prikazanih polja (kolona) result set-a. Ukoliko je zvezdica zadata nakon SELECT naredbe tada će se izlistati sve kolone. Ukoliko nije potrebno prikazivanje svih kolona, spisak potrebnih kolona se navodi nakon SELECT. Kolone pri nabrajanju se razdvajaju zarezom.
SELECT column_name, column_name
FROM table_name;
Ukoliko nije potrebno prikazivanje svih kolona, spisak potrebnih kolona se nabraja nakon ključne reči SELECT. Kolone se pri nabrajanju razdvajaju zarezom.
SELECT DISTINCT column_name, column_name
FROM table_name;
Ukoliko naredba SELECT sadrži u svom nastavku ključnu reč DISTINCT, izlistaće se samo različiti podaci u zadatoj koloni (kolonama). Nijedan podatak u zadatoj koloni (kolonama) se neće ponavljati.
SELECT column_name, column_name
FROM table_name
WHERE column_name operator value;
Naredba WHERE spisak izlistanih rekorda sužava samo na rekorde čija
polja zadovoljavaju zadati uslov. U zadatoj koloni (polju) podaci treba
da ispune uslov da bi bili izlistani. Na primer ukoliko su u "Price"
koloni brojčane vrednosti a u "Name" koloni tekstualne vrednosti,
mogući uslovi bi glasili:
WHERE Price > 18
Ukoliko polje sadrži tekst podatak posle operatora mora da bude unutar
navodnika, naprimer
WHERE Name = "Steve"
Dozvoljeni operatori:
Operator | Objašnjenje |
---|---|
= | Jednako |
< > | Različito |
> | Veće od |
< | Manje od |
>= | Veće ili jednako |
<= | Manje ili jednako |
BETWEEN | Između zadatih vrednosti |
LIKE | Kao |
IN | Sadrži |
Operatori AND i OR omogućavaju sužavanje izbora rekorda upotrebom više od jednog uslova.
Operator AND prikazuje rekord kada su oba uslova tačna.
SELECT column_name, column_name
FROM table_name
WHERE column_name operator value AND
column_name operator value;
Operator OR prikazuje rekord kada je barem jedan od uslova tačan.
SELECT column_name, column_name
FROM table_name
WHERE column_name operator value OR
column_name operator value;
Operatori AND i OR se mogu kombinovati uz upotrebu zagrada na različite načine. Zagrade imaju sličnu namenu kao i pri matematičkim operacijama.
SELECT column_name, column_name
FROM table_name
WHERE column_name operator value OR
(column_name operator value AND
column_name operator value);
SELECT column_name, column_name
FROM table_name
ORDER BY column_name ASC|DESC, column_name ASC|DESC;
Naredba ORDER BY omogućava redosledni prikaz dobijenog rezultata nakon SQL iskaza. Podrazumevani redosled kod brojeva je rastući a kod teksta je abecedni redosled. Dozvoljene ključne reči za regulisanje redosleda prikaza su ASC (rastući) i DESC (opadajući) redosled.
Naredba INSERT INTO se upotrebljava za umetanje novog rekorda u tabelu. Naredbu je moguće pisati u dva oblika:
INSERT INTO table_name
VALUES (value1, value2, value3, ...);
ili
INSERT INTO table_name (column1, column2, column3, ...)
VALUES (value1, value2, value3, ...);
U prvom obliku se ne zadaju imena kolona (polja) u koje se unose vrednosti.
UPDATE iskaz služi za izmenu podataka u tabeli.
UPDATE table_name
SET column1 = value1, column2 = value2, ...
WHERE some_column = some_value;
Potrebno je obratiti pažnju na WHERE ključnu reč u SQL UPDATE izjavi!
WHERE ključna reč zadaje koji rekord ili rekordi će biti promenjeni.
Ukoliko se izostavi WHERE ključna reč, svi rekordi u tabeli će biti
promenjeni!
Iskaz DELETE služi za brisanje rekorda iz tabele.
DELETE FROM table_name
WHERE some_column = some_value;
Potrebno je obratiti pažnju na WHERE ključnu reč u SQL DELETE izjavi!
WHERE ključna reč zadaje koji rekord ili rekordi će biti obrisani.
Ukoliko se izostavi WHERE ključna reč, svi rekordi u tabeli će biti
obrisani!
Iskaz SELECT TOP se upotrebljava za zadavanje broja rekorda koji će se pojaviti u rezultatu upita. Ovaj iskaz može da bude veoma koristan pri radu sa velikim tabelama. Učitavanje velikog broja rekorda može drastično da utiče na performanse.
Iskaz SELECT TOP nije podržan od strane svih sistema baze podataka.
Primer za SQL Server/MS Access:
SELECT TOP number|percent column_name(s)
FROM table_name;
Primer za MySQL:
SELECT column_name(s)
FROM table_name
LIMIT number;
Primer za Oracle:
SELECT column_name(s)
FROM table_name
WHERE ROWNUM <= number;
Operator LIKE se upotrebljava u naredbi WHERE za traženje zadatog niza karaktera za dato polje.
SELECT column_name(s)
FROM table_name
WHERE column_name LIKE pattern;
Pattern predstavlja niz karaktera u kojem se najčešće nalaze džoker znaci.
Džokeri se u SQL-u upotrebljavaju uz operator LIKE da zamene bilo koji karakter u stringu za pretragu.
Džokeri u SQL-u su:
Džoker | Opis |
---|---|
% | zamena za nula ili više karaktera |
_ | zamena za jedan karakter |
[lista karaktera] | lista traženih karaktera |
[^lista karaktera] ili [!lista karaktera] |
lista karaktera koji se NE smeju naći u rekordima |
SELECT *
FROM table_name
WHERE column_name LIKE 'srb%';
Pronalaženje svih rekorda koji počinju sa 'srb'.
SELECT *
FROM table_name
WHERE column_name LIKE '%ija';
Pronalaženje svih rekorda koji se završavaju sa 'ija'.
SELECT *
FROM table_name
WHERE column_name LIKE '%rbi%';
Pronalaženje svih rekorda koji u sredini sadrže niz karaktera 'rbi'.
SELECT *
FROM table_name
WHERE column_name LIKE '_rbija';
Pronalaženje svih rekorda koji počinju sa bilo kojim karakterom i završavaju se sa 'rbija'.
SELECT *
FROM table_name
WHERE column_name LIKE 's_b_j_';
Pronalaženje svih rekorda koji počinju sa karakterom 's', nakon njega sledi bilo koji karakter, zatim sledi karakter 'b', nakon njega sledi bilo koji karakter, zatim sledi karakter 'j' i nakon njega sledi bilo koji karakter.
SELECT *
FROM table_name
WHERE column_name LIKE '[bsp]%';
Pronalaženje svih rekorda koji počinju karakterima 'b', 's' ili 'p' i završavaju se bilo kojim nizom karaktera.
SELECT *
FROM table_name
WHERE column_name LIKE '[a-c]%';
Pronalaženje svih rekorda koji počinju karakterima 'a', 'b' ili 'c' i završavaju se bilo kojim nizom karaktera.
SELECT *
FROM table_name
WHERE column_name NOT LIKE '[bsp]%';
Pronalaženje svih rekorda koji NE počinju karakterima 'b', 's' ili 'p'.
Operator IN omogućava zadavanje više vrednosti u WHERE klauzulu.
SELECT column_name(s)
FROM table_name
WHERE column_name IN (value1,value2,...);
Operator BETWEEN omogućava zadavanje intervala vrednosti u kojima se traže vrednosti. Vrednosti mogu biti brojčane, tekst ili datumi.
SELECT column_name(s)
FROM table_name
WHERE column_name BETWEEN value1 AND value2;
U sledećem primeru se biraju svi priozvodi čija JE cena između 10 i 20.
SELECT *
FROM products
WHERE Price BETWEEN 10 AND 20;
U sledećem primeru se biraju svi priozvodi čija cena NIJE između 10 i 20.
SELECT *
FROM products
WHERE Price NOT BETWEEN 10 AND 20;
Alijasi se upotrebljavaju da se privremeno upotrebi drugo ime za tabelu ili polje (kolonu). Alijasi se kreiraju da imena polja (kolona) budu čitljivija.
SQL alijas sintaksa za kolonu:
SELECT column_name AS alias_name
FROM table_name;
SQL alijas sintaksa za tabelu:
SELECT column_name(s)
FROM table_name AS alias_name;
U narednom primeru se u SQL iskazu zadaju dva alijasa, jedan za column_name_1 a drugi za column_name_2. Potrebni su dvostruki navodnici ili uglaste zagrade ukoliko se upotrebljava naziv koji sadrži prazno mesto.
SELECT col_1 AS alias1, col_2 AS [alias 2]
FROM table_name;
U narednom primeru se u SQL iskazu kombinuje više kolona, čije će vrednosti biti razdvojene zarezima.
SELECT col_1, col_2+ ', ' +col_3+ ', ' +col_4+ ', ' +col_5 AS Address
FROM table_name;
U slučaju MySQL baze:
SELECT col_1, CONCAT(col_2, ', ', col_3, ', ', col_4, ', ', col_5) AS Address
FROM table_name;
U narednom primeru se imena tabela zamenjuju alijasima od po jednog slova, čime se i sam SQL upit skraćuje.
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;
Isti upit bez alijasa:
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;
Alijasi mogu biti korisni u sledećim slučajevima:
SQL JOIN omogućava spajanje redova dve ili više tabela. Spajanje je zasnovano na zajedničkim redovima koji se nalaze u tabelama.
Najčešći oblik spajanja je SQL INNER JOIN (simple join) jednostavno spajanje. SQL INNER JOIN prikazuje sve redove iz više tabela gde je join uslov ispunjen.
Tabela Orders
OrderID | CustomerID | OrderDate |
---|---|---|
10308 | 2 | 1996-09-18 |
10309 | 37 | 1996-09-19 |
10310 | 77 | 1996-09-20 |
Tabela Customers
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 |
Može se primetiti da polje "CustomerID" u "Orders" tabeli upućuje na "CustomerID" polje u "Customers" tabeli. Relacija između ove dve tabele je "CustomerID" kolona. Ukoliko se izvrši sledeći upit koji sadrži (INNER JOIN):
SELECT Orders.OrderID, Customers.CustomerName, Orders.OrderDate
FROM Orders
INNER JOIN Customers
ON Orders.CustomerID = Customers.CustomerID;
Dobija se:
OrderID | CustomerName | OrderDate |
---|---|---|
10308 | Ana Trujillo Emparedados y helados | 1996-09-18 |
Isti rezultat daje i sledeći upit:
SELECT Orders.OrderID, Customers.CustomerName, Orders.OrderDate
FROM Customers
INNER JOIN Orders
ON Customers.CustomerID = Orders.CustomerID;
SQL INNER JOIN i JOIN se podudaraju.
Ključna reč INNER JOIN bira sve redove iz obadve tabele za koje postoje zajedničke vrednosti u kolonama obe tabele.
SELECT column_name(s)
FROM table1
INNER JOIN table2
ON table1.column_name = table2.column_name;
SELECT column_name(s)
FROM table1
JOIN table2
ON table1.column_name = table2.column_name;
SQL LEFT JOIN prikazuje sve redove iz leve tabele (table1), sa odgovarajućim redovima iz desne tabele (table2). Rezultat je NULL na desnoj strani ukoliko nema podudaranja.
SELECT column_name(s)
FROM table1
LEFT JOIN table2
ON table1.column_name = table2.column_name;
SELECT column_name(s)
FROM table1
LEFT OUTER JOIN table2
ON table1.column_name = table2.column_name;
U nekim rukovaocima baza podataka LEFT JOIN se zove LEFT OUTER JOIN.
Tabela Orders
OrderID | CustomerID | OrderDate |
---|---|---|
10308 | 2 | 1996-09-18 |
10309 | 37 | 1996-09-19 |
10310 | 77 | 1996-09-20 |
10311 | 2 | 1996-09-21 |
Tabela Customers
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 |
Ukoliko se izvrši sledeći upit:
SELECT Customers.CustomersName, Orders.OrderID
FROM Customers
LEFT JOIN Orders
ON Customers.CustomerID = Orders.CustomerID
ORDER BY Customers.CustomerName;
Prikazuju se svi redovi iz tabele Customers, i za one koji imaju narudžbu, pojavljuje se broj narudžbe. Ukoliko isti kupac ima više narudžbi, njegovo ime se ponavlja za svaku narudžbu:
CustomerName | OrderID |
---|---|
Alfreds Futterkiste | |
Ana Trujillo Emparedados y helados | 10308 |
Ana Trujillo Emparedados y helados | 10311 |
Antonio Moreno Taquería |
SQL RIGHT JOIN prikazuje sve redove iz desne tabele (table2), sa odgovarajućim redovima iz leve tabele (table1). Rezultat je NULL na levoj strani ukoliko nema podudaranja.
SELECT column_name(s)
FROM table1
RIGHT JOIN table2
ON table1.column_name = table2.column_name;
SELECT column_name(s)
FROM table1
RIGHT OUTER JOIN table2
ON table1.column_name = table2.column_name;
U nekim rukovaocima baza podataka RIGHT JOIN se zove RIGHT OUTER JOIN.
Tabela Orders
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 |
Tabela Employees
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 |
Ukoliko se izvrši sledeći upit:
SELECT Orders.OrderID, Employees.FirstName
FROM Orders
RIGHT JOIN Employees
ON Orders.EmployeeID = Employees.EmployeeID
ORDER BY Orders.OrderID;
Prikazuju se svi redovi iz desne tabele (Employees) čak i ako nemaju podudaranja sa levom tabelom:
OrderID | FirstName |
---|---|
Nancy | |
10308 | Janet |
10309 | Andrew |
10310 | Janet |
SQL FULL JOIN prikazuje sve redove iz obe tabele. FULL OUTER JOIN spaja rezultate LEFT i RIGHT JOIN-a.
SELECT column_name(s)
FROM table1
FULL OUTER JOIN table2
ON table1.column_name = table2.column_name;
Tabela Customers
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 |
Tabela Orders
OrderID | CustomerID | OrderDate |
---|---|---|
10308 | 2 | 1996-09-18 |
10309 | 37 | 1996-09-19 |
10310 | 77 | 1996-09-20 |
Ukoliko se izvrši sledeći upit:
SELECT Customers.CustomerName, Orders.OrderID
FROM Customers
FULL OUTER JOIN Orders
ON Customers.CustomerID = Orders.CustomerID
ORDER BY Customers.CustomerName;
Prikazuju se svi redovi iz obadve tabele čak i ako nemaju podudaranja.
CustomerName | OrderID |
---|---|
Alfreds Futterkiste | |
Ana Trujillo Emparedados y helados | 10308 |
Antonio Moreno Taquería | |
10309 | |
10310 |
SQL UNION spaja rezultate dve ili više SELECT izjave. Potrebno je da svaka SELECT izjava u sklopu UNION mora da ima isti broj kolona. Kolone takođe moraju da budu istih tipova. Takođe kolone svake SELECT izjave moraju da budu u istom redosledu.
SELECT column_name(s) FROM table1
UNION
SELECT column_name(s) FROM table2;
UNION operator podrazumevano bira samo različite vrednosti. Za dozvolu duplikata se upotrebljava ključna reč ALL uz UNION.
SELECT column_name(s) FROM table1
UNION ALL
SELECT column_name(s) FROM table2;
Imena kolona u result-setu UNION-a se najčešće poklapaju sa imenima kolona prve SELECT izjave u UNION-u.
Tabela Customers
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 |
Tabela Suppliers
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 |
Ukoliko se izvrši sledeći upit:
SELECT City FROM Customers
UNION
SELECT City FROM Suppliers
ORDER BY City;
Dobija se sledeći rezultat (UNION prikazuje samo različite vrednosti):
City |
---|
Ann Arbor |
Berlin |
London |
México D.F. |
New Orleans |
Tabela Customers
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 |
Tabela Suppliers
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 |
Ukoliko se izvrši sledeći upit:
SELECT City FROM Customers
UNION ALL
SELECT City FROM Suppliers
ORDER BY City;
Dobija se sledeći rezultat (UNION ALL prikazuje i duplikate):
City |
---|
Ann Arbor |
Berlin |
London |
México D.F. |
México D.F. |
New Orleans |
Tabela Customers
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 |
Tabela Suppliers
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 |
Ukoliko se izvrši sledeći upit:
SELECT City, Country FROM Customers
WHERE Country = "Mexico"
UNION ALL
SELECT City, Country FROM Suppliers
WHERE Country = "USA"
ORDER BY City;
Dobija se sledeći rezultat (UNION ALL prikazuje i duplikate):
City | Country |
---|---|
Ann Arbor | USA |
México D.F. | Mexico |
México D.F. | Mexico |
New Orleans | USA |
Uz pomoć SQL-a se mogu kopirati podaci iz jedne tabele u drugu.
SQL iskaz SELECT INTO kopira samo odabrane podatke u novu tabelu.
Kopiranje svih kolona u novu tabelu:
SELECT *
INTO newtable [IN externaldb]
FROM table1;
Kopiranje odabranih kolona u novu tabelu:
SELECT column_name(s)
INTO newtable [IN externaldb]
FROM table1;
Nova tabela će biti kreirana sa imenima kolona i tipovima podataka kao što je i definisano u SELECT iskazu. Mogu se primeniti nova imena upotrebom AS klauzule.
Kreiranje rezervne kopije Customers tabele:
SELECT *
INTO CustomersBackup2013
FROM Customers;
Upotreba ključne reči IN za kopiranje tabele u drugu bazu podataka:
SELECT *
INTO CustomersBackup2013 IN 'Backup.mdb'
FROM Customers;
Kopiranje samo pojedinih kolona u novu tabelu:
SELECT CustomerName, ContactName
INTO CustomersBackup2013
FROM Customers;
Kopiranje samo Nemačkih kupaca u novu tabelu:
SELECT *
INTO CustomersBackup2013
FROM Customers
WHERE Country = 'Germany';
Kopiranje podataka iz više tabela u novu tabelu:
SELECT Customers.CustomerName, Orders.OrderID
INTO CustomersOrderBackup2013
FROM Customers
LEFT JOIN Orders
ON Customers.CustomerID = Orders.CustomerID;
SELECT INTO iskaz može da se upotrebi za kreiranje nove, prazne tabele zasnovane na šemi neke druge tabele. Potrebno je zadati WHERE uslov koji ne vraća podatke:
SELECT *
INTO newtable
FROM table1
WHERE 1=0;
Uz pomoć SQL-a se mogu kopirati podaci iz jedne tabele u drugu, postojeću tabelu.
SQL iskaz INSERT INTO SELECT kopira samo odabrane podatke u drugu tabelu. Postojeći podaci u ciljnoj tabeli će ostati nepromenjeni.
Kopiranje svih kolona iz jedne tabele u drugu, postojeću tabelu:
INSERT INTO table2
SELECT *
FROM table1;
Kopiranje samo odabranih kolona u drugu, postojeću tabelu:
INSERT INTO table2
(column_name(s))
SELECT column_name(s)
FROM table1;
Tabela Customers
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 |
Tabela Suppliers
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 |
Kopiranje samo pojedinih kolona iz "Suppliers" u "Customers" tabelu:
INSERT INTO Customers (CustomerName, Country)
SELECT SupplierName, Country
FROM Suppliers
Tabela Customers nakon iskaza izgleda ovako:
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 |
Kopiranje samo dobavljača iz USA iz "Suppliers" tabele u "Customers" tabelu:
INSERT INTO Customers (CustomerName, Country)
SELECT SupplierName, Country
FROM Suppliers
WHERE Country='USA';
Tabela Customers nakon iskaza izgleda ovako:
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 |
Iskaz CREATE DATABASE se upotrebljava za kreiranje baze podataka.
Kreiranje baze podataka:
CREATE DATABASE dbname;
Kreiranje baze podataka pod nazivom "my_db":
CREATE DATABASE my_db;
Iskaz CREATE TABLE se upotrebljava za kreiranje tabele.
Tabele su organizovane u redove i kolone. Svaka tabela mora imati ime.
Kreiranje tabele:
CREATE TABLE table_name
(
column_name1 data_type(size),
column_name2 data_type(size),
column_name3 data_type(size),
...
);
Parametar column_name zadaje ime kolone.
Parametar data_type zadaje tip podataka kolone (naprimer varchar, integer, decimal, date, i tako dalje).
Parametar size zadaje maksimalnu dužinu kolone.
Kreiranje tabele koja će se zvati "Persons" koja sadrži pet kolona: PersonID, LastName, FirstName, Address i City.
Iskaz ovako izgleda:
CREATE TABLE Persons
(
PersonID int,
LastName varchar(255),
FirstName varchar(255),
Address varchar(255),
City varchar(255)
);
PersonID kolona je int tipa i u njoj će se nalaziti integeri.
LastName, FirstName, Address i City kolone su tipa varchar, sadržavaće karaktere i maksimalna dužina ovih polja je 255 karaktera.
Prazna "Persons" tabela izgleda ovako:
PersonID | LastName | FirstName | Address | City |
---|---|---|---|---|
. |
Prazna tabela može da se popuni podacima uz upotrebu INSERT INTO iskaza.
SQL constraints (ograničenja) se upotrebljavaju da se zadaju pravila za podatke u tabeli. Ukoliko postoji narušavanje između constraint (ograničenja) i akcije nad podacima, akciju će prekinuti constrain (ograničenje). Constraints (ograničenja) mogu da se zadaju pri kreiranju tabele (unutar iskaza CREATE TABLE) ili u postojećoj tabeli (unutar ALTER TABLE iskaza).
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,
....
);
U SQL-u postoje sledeći constrainti (ograničenja):
Constraint | Opis |
---|---|
NOT NULL | Ukazuje da se u koloni ne može naći vrednost NULL |
UNIQUE | Obezbeđuje da svaki red u koloni mora da ima jedinstvenu vrednost |
PRIMARY KEY | Kombinacija NOT NULL i UNIQUE. Obezbeđuje da kolona (ili kombinacija dve ili više kolona) ima jedinstveni identitet koji pomaže nalaženju specifičnog rekorda u tabeli lakše i brže |
FOREIGN KEY | Obezbeđuje referencijalni integritet podataka iz jedne tabele da ima odgovarajuće vrednosti u drugoj tabeli |
CHECK | Obezbeđuje da vrednosti u koloni zadovolje posebne uslove |
DEFAULT | Zadaje podrazumevanu vrednost za kolonu |
Podrazumevano kolona tabele može da sadrži NULL vrednosti. NOT NULL constraint (ograničenje) sprečava da kolona prihvati NULL vrednost. NOT NULL constraint (ograničenje) primorava polje da uvek sadrži neku vrednost. To znači da se ne može uneti novi rekord ili ažurirati rekord bez dodavanja vrednosti za ovo polje. Naredni SQL primorava kolonu "P_Id" i "LastName" kolonu da ne prihvate NULL vrednosti:
CREATE TABLE PersonsNotNull
(
P_Id int NOT NULL,
LastName varchar(255) NOT NULL,
FirstName varchar(255),
Address varchar(255),
City varchar(255)
);
UNIQUE constraint jedinstveno identifikuje svaki rekord u tabeli baze podataka. UNIQUE i PRIMARY KEY constrainti obezbeđuju garanciju za jedinstvenost kolone ili skupa kolona. PRIMARY KEY constraint automatski poseduje definisan UNIQUE constraint. Primetiti da se može imati više UNIQUE constrinta po tabeli ali samo jedan PRIMARY KEY constraint po tabeli.
Naredni SQL iskaz kreira UNIQUE constraint na "P_Id" koloni pri kreiranju "Persons" tabele:
CREATE TABLE Persons
(
P_Id int NOT NULL UNIQUE,
LastName varchar(255) NOT NULL,
FirstName varchar(255),
Address varchar(255),
City varchar(255)
);
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)
);
Dozvola davanja imena UNIQUE constrainta i za definisanje UNIQUE constrainta nad više kolona upotrebljava se sledeća SQL sintaksa:
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)
);
Za kreiranje UNIQUE constarint na koloni "P_Id" kada je tabela već kreirana, upotrebljava se sledeći SQL:
ALTER TABLE Persons
ADD UNIQUE (P_Id);
Za dozvolu davanja imena UNIQUE constraint i za definisanje UNIQUE constrainta nad više kolona upotrebljava se sledeća SQL sintaksa:
ALTER TABLE Persons
ADD CONSTRAINT uc_PersonID UNIQUE (P_Id,LastName);
Za uklanjanje UNIQUE constrainta se upotrebljava sledeći SQL:
ALTER TABLE Persons
DROP INDEX uc_PersonID;
ALTER TABLE Persons
DROP CONSTRAINT uc_PersonID;
PRIMARY KEY constraint jedinstveno identifikuje svaki rekord u tabeli baze podataka. Primarni ključ mora sadržavati JEDINSTVENE vrednosti. Kolona "primary key" ne može da sadrži NULL vrednosti. Većina tabela treba da ima primarni ključ ali svaka tabela može da ima samo JEDAN primarni ključ.
Naredni SQL kreira PRIMARY KEY na koloni "P_Id" pri kreiranju tabele "Persons":
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)
);
CREATE TABLE Persons
(
P_Id int NOT NULL PRIMARY KEY,
LastName varchar(255) NOT NULL,
FirstName varchar(255),
Address varchar(255),
City varchar(255)
);
Za dozvolu davanja imena PRIMARY KEY constrainta i za definisanje PRIMARY KEY constrainta na više kolona upotrebiti SQL sintaksu:
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)
);
NAPOMENA:
U gornjem primeru je samo jedan primarni ključ (pl_PersonID). Vrednost
primarnog ključa se pravi od dve kolone (P_Id i LastName).
Za kreiranje PRIMARY KEY constrainta na koloni "P_Id" kada je tabela već kreirana upotrebljava se sledeći SQL:
ALTER TABLE Persons
ADD PRIMARY KEY (P_Id);
Za dozvolu davanja imena PRIMARY KEY constrainta i za definisanje PRIMARY KEY constrainta na više kolona upotrebiti sledeću SQL sintaksu:
ALTER TABLE Persons
ADD CONSTRAINT pk_PersonID PRIMARY KEY (P_Id, LastName);
NAPOMENA:
Ukoliko se upotrebljava ALTER TABLE iskaz za dodavanje primarnog ključa,
kolona primarnog ključa mora da već bude definisana da ne sadrži NULL
vrednosti (kada je tabela kreirana).
Za uklanjanje PRIMARY KEY constrainta upotrebiti sledeći SQL:
ALTER TABLE Persons
DROP PRIMARY KEY;
ALTER TABLE Persons
DROP CONSTRAINT pk_PersonID;
FOREIGN KEY u jednoj tabeli ukazuje na PRIMARY KEY u drugoj tabeli.
Ilustracija stranog ključa (foreign key) na primeru:
"Persons" tabela:
P_Id | LastName | FirstName | Address | City |
---|---|---|---|---|
1 | Hansen | Ola | Timotevin 10 | Sandnes |
2 | Svendson | Tove | Borgvn 23 | Sandnes |
3 | Pettersen | Kari | Storgt 20 | Stavanger |
"Orders" tabela:
O_Id | OrderNo | P_Id |
---|---|---|
1 | 77895 | 3 |
2 | 44678 | 3 |
3 | 22456 | 2 |
4 | 24562 | 1 |
Može se primetiti da kolona "P_Id" u tabeli "Orders" ukazuje na "P_Id" kolonu u "Persons" tabeli.
Kolona "P_Id" u tabeli "Persons" je PRIMARY KEY (primarni ključ).
Kolona "P_Id" u tabeli "Orders" je FOREIGN KEY (strani ključ).
FOREIGN KEY constraint se upotrebljava da spreči akcije koje bi uništile vezu između tabela.
FOREIGN KEY constraint takođe sprečava unos nevalidnog podatka u kolonu stranog ključa pošto mora da bude jedna od vrednosti sadržanih u tabeli na koju ukazuje.
Naredni SQL kreira FOREIGN KEY na "P_Id" koloni prilikom kreiranja "Orders" tabele:
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)
);
CREATE TABLE Orders
(
O_Id int NOT NULL PRIMARY KEY,
OrderNo int NOT NULL,
P_Id int FOREIGN KEY REFERENCES Persons(P_Id)
);
Za dozvolu davanja imena FOREIGN KEY constrainta i za definisanje FOREIGN KEY constrainta na više kolona upotrebiti sledeću SQL sintaksu:
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)
);
Za kreiranje FOREIGN KEY constrainta na koloni "P_Id" kada je tabela "Orders" već kreirana upotrebiti sledeći SQL:
ALTER TABLE Orders
ADD FOREIGN KEY (P_Id)
REFERENCES Persons(P_Id);
Za dozvolu davanja imena FOREIGN KEY constrainta i za definisanje FOREIGN KEY constrainta na više kolona upotrebiti SQL sintaksu:
ALTER TABLE Orders
ADD CONSTRAINT fk_PerOrders
FOREIGN KEY (P_Id)
REFERENCES Persons(P_Id);
Za uklanjanje FOREIGN KEY constrainta upotrebiti sledeći SQL:
ALTER TABLE Orders
DROP FOREIGN KEY fk_PerOrders;
ALTER TABLE Orders
DROP CONSTRAINT fk_PerOrders;
CHECK constraint se upotrebljava da ograniči opseg vrednosti koji se može smestiti u kolonu. Ukoliko se definiše CHECK constraint na jednu kolonu to dozvoljava samo određene vrednosti za tu kolonu. Ukoliko se definiše CHECK constraint na tabelu to može da ograniči vrednosti u određenim kolonama zasnovanim na vrednostima u drugim kolonama u tom redu.
Naredni SQL iskaz kreira CHECK constraint na koloni "P_Id" pri kreiranju tabele "Persons". CHECK constraint zadaje da kolona "P_Id" može da sadrži samo integere veće od 0:
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)
);
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)
);
Za dozvolu davanja imena CHECK constraintu i za definisanje CHECK constrainta na više kolona upotrebiti sledeću SQL sintaksu:
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')
);
Za kreiranje CHECK constrainta na koloni "P_Id" kada je tabela već kreirana upotrebljava se sledeći SQL:
ALTER TABLE Persons
ADD CHECK (P_Id>0);
Za dozvolu davanja imena CHECK constraintu i za definisanje CHECK constrainta na više kolona upotrebljava se sledeća SQL sintaksa:
ALTER TABLE Persons
ADD CONSTRAINT chk_Person CHECK (P_Id>0 AND City='Sandnes');
Za uklanjanje CHECK constrainta se upotrebljava sledeći SQL:
ALTER TABLE Persons
DROP CHECK chk_Person;
ALTER TABLE Persons
DROP CONSTRAINT chk_Person;
DEFAULT constraint se upotrebljava da bi se unela podrazumevana vradnost u kolonu. Podrazumevana vrednost će se dodati svim novim rekordima ukoliko nije zadata druga vrednost.
Naredni SQL kreira DEFAULT constraint kolone "City" pri kreiranju "Persons" tabele:
CREATE TABLE Persons
(
P_Id int NOT NULL,
LastName varchar(255) NOT NULL,
FirstName varchar(255),
Address varchar(255),
City varchar(255) DEFAULT 'Sandnes'
);
DEFAULT constraint može takođe da se upotrebi za unos sistemskih vrednosti uz upotrebu funkcija kao GETDATE():
CREATE TABLE Orders
(
O_Id int NOT NULL,
OrderNo int NOT NULL,
P_Id int,
OrderDate date DEFAULT GETDATE()
);
Za kreiranje DEFAULT constraint u koloni "City" kada je tabela već kreirana upotrebiti naredni SQL:
ALTER TABLE Persons
ALTER City SET DEFAULT 'SANDNES';
ALTER TABLE Persons
ALTER COLUMN City SET DEFAULT 'SANDNES';
ALTER TABLE Persons
MODIFY City DEFAULT 'SANDNES';
Za uklanjanje DEFAULT constrainta upotrebiti sledeći SQL:
ALTER TABLE Persons
ALTER City DROP DEFAULT;
ALTER TABLE Persons
ALTER COLUMN City DROP DEFAULT;
Iskaz CREATE INDEX se upotrebljava za kreiranje indeksa u tabelama. Indeksi omogućavaju aplikacijama da podatke nađu brzo bez čitanja cele tabele.
Indeks se kreira u tabeli da bi se podaci našli brže i efikasnije. Korisnici ne mogu da vide indekse, oni se samo koriste da bi se ubrzalo traženje i upiti.
NAPOMENA:
Ažuriranje tabele sa indeksima traje duže nego ažuriranje tabele bez indeksa
(pošto se i indeksi moraju ažurirati). Iz ovog razloga se kreiraju indeksi samo
na kolonama (tabelama) nad kojima će se često vršiti pretrage.
Kreiranje indeksa u tabeli. Duplirane vrednosti su dozvoljene:
CREATE INDEX index_name
ON table_name (column_name);
Kreira UNIQUE indeks u tabeli. Duplirane vrednosti nisu dozvoljene:
CREATE UNIQUE INDEX index_name
ON table_name (column_name);
NAPOMENA:
Sintaksa za kreiranje indeksa se razlikuje u različitim bazama podataka. Iz
ovog razloga uvek proveriti sintaksu kreiranja indeksa.
Naredni SQL iskaz kreira indeks pod imenom "PIndex" u koloni "LastName" koja je u "Persons" tabeli:
CREATE INDEX PIndex
ON Persons (LastName);
Ukoliko se želi kreiranje indeksa na kombinaciji kolona potrebno je navesti imena kolona unutar zagrade razdvojene zarezom:
CREATE INDEX PIndex
ON Persons (LastName, FirstName);
Indeksi, tabele i baze podataka mogu lako da se obrišu/uklone DROP iskazom.
Iskaz DROP INDEX se upotrebljava za brisanje indeksa u tabeli.
ALTER TABLE table_name DROP INDEX index_name;
DROP INDEX index_name ON table_name;
DROP INDEX table_name.index_name;
DROP INDEX index_name;
Iskaz DROP TABLE se upotrebljava za brisanje tabele.
DROP TABLE table_name;
Iskaz DROP DATABASE se upotrebljava za brisanje baze podataka.
DROP DATABASE database_name;
Ukoliko je potrebno obrisati samo podatke u tabeli a ne i samu tabelu, upotrebljava se iskaz TRUNCATE TABLE.
TRUNCATE TABLE table_name;
Iskaz ALTER TABLE se upotrebljava za dodavanja, brisanja ili izmene kolona u postojećoj tabeli.
Za dodavanje kolona tabeli upotrebljava se sledeća sintaksa:
ALTER TABLE table_name
ADD column_name datatype;
Za brisanje kolona u tabeli upotrebljava se sledeća sintaksa (neke baze podataka ne dozvoljavaju bisanje kolona):
ALTER TABLE table_name
DROP COLUMN column_name;
Za promenu tipova podataka kolone u tabeli upotrebljava se sledeća sintaksa:
ALTER TABLE table_name
ALTER COLUMN column_name datatype;
ALTER TABLE table_name
MODIFY COLUMN column_name datatype;
ALTER TABLE table_name
MODIFY column_name datatype;
Tabela "Persons":
P_Id | LastName | FirstName | Address | City |
---|---|---|---|---|
1 | Hansen | Ola | Timoteivn 10 | Sandnes |
2 | Svendson | Tove | Borgvn 23 | Sandnes |
3 | Pettersen | Kari | Storgt 20 | Stavanger |
Tabeli "Persons" se želi dodati kolona pod imenom "DateOfBirth". Upotrebljava se sledeći iskaz:
ALTER TABLE table_name
ADD DateOfBirth date;
Primetiti da je nova kolona "DateOfBirth" tipa datum i sadržavaće samo podatke ovog tipa. "datatype" zadaje koji će tip podataka da bude u koloni.
Tabela "Persons" sada izgleda ovako:
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 |
Sada se želi promeniti tip podataka u koloni pod imenom "DateOfBirth" u "Persons" tabeli.
Upotrebljava se sledeći SQL iskaz:
ALTER TABLE table_name
ALTER COLUMN DateOfBirth year;
Sada je "DateOfBirth" kolona sada tipa year i čuvaće godinu u dvocifrenom ili četvorocifrenom formatu.
Sada se želi obrisati kolona pod imenom "DateOfBirth" u "Persons" tabeli.
Upotrebljava se sledeći SQL iskaz:
ALTER TABLE table_name
DROP COLUMN DateOfBirth;
"Persons" tabela sada ovako izgleda:
P_Id | LastName | FirstName | Address | City |
---|---|---|---|---|
1 | Hansen | Ola | Timoteivn 10 | Sandnes |
2 | Svendson | Tove | Borgvn 23 | Sandnes |
3 | Pettersen | Kari | Storgt 20 | Stavanger |
Autoincrement omogućava generisanje jedinstvenih brojeva kada se novi rekord doda tabeli.
Veoma često je potrebno generisanje primarnog ključa automatski kada se novi rekord doda u tabelu.
Sledeći SQL iskaz definiše "ID" kolonu da bude autoincrement polje primarni ključ u "Persons" tabeli:
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)
);
MySQL upotrebljava AUTO_INCREMENT ključnu reč da kreira autoincrement osobinu.
Podrazumevano početna vrednost za AUTO_INCREMENT je 1 i uvećava se za 1 svakim novim rekordom.
Za pokretanje AUTO_INCREMENT sekvence sa drugim početnim brojem upotrebljava se sledeća SQL iskaz:
ALTER TABLE Persons
AUTO_INCREMENT=100
Za unos novog rekorda u "Persons" tabelu NE treba zadati vrednost za kolonu "ID" (a jedinstvena vrednost će se dodati automatski):
INSERT INTO Persons (FirstName,LastName)
VALUES ('Lars','Monsen');
SQL iskaz iznad će dodati novi rekord u "Persons" tabelu. Koloni "ID" će biti dodeljena jedinstvena vrednost. Koloni "FirstName" će biti dodeljeno "Lars", a koloni "LastName" će biti dodeljeno "Monsen".
Sledeći SQL iskaz definiše "ID" kolonu da bude autoincrement polje primarni ključ u "Persons" tabeli:
CREATE TABLE Persons
(
ID int IDENTITY(1,1) PRIMARY KEY,
LastName varchar(255) NOT NULL,
FirstName varchar(255),
Address varchar(255),
City varchar(255)
);
MS SQL Server upotrebljava IDENTITY ključnu reč da kreira autoincrement osobinu. U gornjem primeru početna vrednost za IDENTITY je 1 i inkrementovaće se za 1 sa svakim novim rekordom. Za zadavanje da kolona "ID" počinje vrednošću 10 i uvećava se za po 5 treba promeniti na IDENTITY(10,5). Za unos novog rekorda u "Persons" tabelu NE treba zadati vrednost za kolonu "ID" (a jedinstvena vrednost će se dodati automatski):
INSERT INTO Persons (FirstName,LastName)
VALUES ('Lars','Monsen');
SQL iskaz iznad će dodati novi rekord u "Persons" tabelu. Koloni "ID" će biti dodeljena jedinstvena vrednost. Koloni "FirstName" će biti dodeljeno "Lars", a koloni "LastName" će biti dodeljeno "Monsen".
Sledeći SQL iskaz definiše "ID" kolonu da bude autoincrement polje primarni ključ u "Persons" tabeli:
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)
);
MS Access upotrebljava AUTOINCREMENT ključnu reč da kreira autoincrement osobinu. Podrazumevano početna vrednost za AUTO_INCREMENT je 1 i uvećava se za 1 svakim novim rekordom. Za zadavanje da kolona "ID" počinje vrednošću 10 i uvećava se za po 5 treba promeniti na AUTOINCREMENT(10,5).
Za unos novog rekorda u "Persons" tabelu NE treba zadati vrednost za kolonu "ID" (a jedinstvena vrednost će se dodati automatski):
INSERT INTO Persons (FirstName,LastName)
VALUES ('Lars','Monsen');
SQL iskaz iznad će dodati novi rekord u "Persons" tabelu. Koloni "ID" će biti dodeljena jedinstvena vrednost. Koloni "FirstName" će biti dodeljeno "Lars", a koloni "LastName" će biti dodeljeno "Monsen".
U Oracle kodu je ovo malo drugačije.
Potrebno je kreirati autoincrement polje sa sekvencnim objektom (ovaj objekat generiše brojčanu sekvencu).
Upotrebljava se CREATE SEQUENCE sintaksa:
CREATE SEQUENCE seq_person
MINVALUE 1
START WITH 1
INCREMENT BY 1
CACHE 10
Kod iznad kreira sekvencu pod imenom seq_person koja počinje od jedan i uvećava se za 1. Takođe će keširati do 10 vrednosti za ovu osobinu. Cache opcija zadaje koliko vrednosti sekvenca da bude sačuvano u memoriji iz razloga bržeg pristupa.
Za unos novog rekorda u "Persons" tabelu potrebno je upotrebiti nextval funkciju (ova funkcija vraća sledeću vrednost seq_person sekvence):
INSERT INTO Persons (ID,FirstName,LastName)
VALUES (seq_person.nextval,'Lars','Monsen');
SQL iskaz iznad će dodati novi rekord u "Persons" tabelu. Koloni "ID" će biti dodeljena sledeća vrednost seq_person sekvence. Koloni "FirstName" će biti dodeljeno "Lars", a koloni "LastName" će biti dodeljeno "Monsen".
U SQL-u view je virtuelna tabela zasnovana na result-setu SQL iskaza. View sadrži redove i kolone kao i prava tabela. Polja u view su iz jedne ili više stvarnih tabela u bazama podataka. Mogu da se dodaju SQL funkcije WHERE i JOIN iskaza da se vide i prikažu podaci, ukoliko su podaci iz jedne tabele.
CREATE VIEW view_name AS
SELECT column_name(s)
FROM table_name
WHERE condition;
NAPOMENA:
View uvek prikazuje ažurne podatke. Database engine ponovo kreira podatke
upotrebljavajući SQL iskaz view-a svaki put kada korisnik zatraži view.
View "Current Product List" prikazuje sve aktivne proizvode (proizvodi koji nisu prekinuti) iz tabele "Products". View je kreiran uz pomoć sledećeg SQL-a:
CREATE VIEW [Current Product List] AS
SELECT ProductID, ProductName
FROM Products
WHERE Discontinued = No;
Upit za prikaz view-a:
SELECT *
FROM [Current Product List];
Sledeći view bira svaki priozvod u "Products" tabeli sa cenom koja je iznad prosečne cene:
CREATE VIEW [Products Above Average Price] AS
SELECT ProductName, UnitPrice
FROM Products
WHERE UnitPrice > (SELECT AVG(UnitPrice) FROM Products);
Upit za prikaz view-a:
SELECT *
FROM [Products Above Average Price];
Naredni view računa ukupnu prodaju za svaku kategoriju u 1997. Primetiti da ovaj view bira podatke iz drugog view-a koji se zove "Product Sales for 1997":
CREATE VIEW [Category Sales For 1997] AS
SELECT DISTINCT CategoryName, Sum(ProductSales) AS CategorySales
FROM [Product Sales for 1997]
GROUP BY CategoryName;
Upit za prikaz view-a:
SELECT *
FROM [Category Sales For 1997];
Moguće je dodati uslov za upit. Može se prikazati ukupna prodaja samo za kategoriju "Beverages":
SELECT *
FROM [Category Sales For 1997]
WHERE CategoryName = 'Beverages';
View može da se osveži pomoću sledeće sintakse:
CREATE OR REPLACE VIEW view_name AS
SELECT column_name(s)
FROM table_name
WHERE condition;
Ukoliko je potrebno da se doda kolona "Category" view-u "Current Product List". View se ažurira uz pomoć sledećeg SQL-a:
CREATE OR REPLACE VIEW [Current Product List] AS
SELECT ProductID, ProductName, Category
FROM Products
WHERE Discontinued = No;
View može da se obriše pomoću naredbe DROP VIEW:
DROP VIEW view_name;
Najsloženiji deo rada sa datumima je da format datuma koji se pokušava uneti, slaže sa formatom datuma koji je u datoj koloni baze podataka.
Ukoliko podatak sadrži samo datum, upiti rade kao što se i od njih očekuje. Ukoliko se uključi i vreme, stvari postaju komplikovanije.
Naredna tabela prikazuje najvažnije ugrađene date funkcije u MySQL:
Funkcija | Opis |
---|---|
NOW() | Vraća trenutni datum i vreme |
CURDATE() | Vraća trenutni datum |
CURTIME() | Vraća trenutno vreme |
DATE() | Izvlači datum iz datuma ili datum/vreme izraza |
EXTRACT() | Vraća deo datum/vremena |
DATE_ADD() | Dodaje zadati vremenski interval datumu |
DATE_SUB() | Oduzima zadati vremenski interval od datuma |
DATEDIFF() | Vraća broj dana između dva datuma |
DATE_FORMAT() | Prikazuje podatak datum/vreme u različitim formatima |
Naredna tabela prikazuje najvažnije ugrađene date funkcije u SQL Server:
Funkcija | Opis |
---|---|
GETDATE() | Vraća trenutni datum i vreme |
DATEPART() | Vraća deo datum/vremena |
DATEADD() | Dodaje ili oduzima zadati vremenski interval od datuma |
DATEDIFF() | Vraća vreme između dva datuma |
CONVERT() | Prikazuje podatak datum/vreme u različitim formatima |
MySQL poseduje naredne tipove podataka za datum ili datum/vreme vrednosti:
SQL Server poseduje naredne tipove podataka za datum ili datum/vreme vrednosti:
Dva datuma se lako mogu uporediti ukoliko nema vremenske komponente.
Ukoliko"Orders" tabela izgleda ovako:
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 |
Potrebno je izabrati rekorde sa OrderDate od "2008-11-11" iz tabele.
Upotrebljava se sledeći SELECT iskaz:
SELECT *
FROM Orders
WHERE OrderDate='2008-11-11';
Result-set će ovako izgledati:
OrderID | ProductName | OrderDate |
---|---|---|
1 | Geitost | 2008-11-11 |
3 | Mozzarella di Giovanni | 2008-11-11 |
Ukoliko se pretpostavi da tabela "Orders" izgleda ovako (primetiti vremensku komponentu u "OrderDate" koloni):
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 |
Ukoliko se upotrebi isti SELECT iskaz kao i u gornjem primeru:
SELECT *
FROM Orders
WHERE OrderDate='2008-11-11';
Upit neće dati rezultat. Upit traži samo podatke bez vremenske komponente.
Predlog: Ukoliko se želi da upiti budu jednostavni, ne treba upotrebljavati vremensku komponentu.
NULL vrednosti predstavljaju nedostajuće ili nepoznate podatke. Podrazumevano kolone mogu da sadrže NULL vrednosti.
Ukoliko je kolona u tabeli opcionalna moguće je uneti rekord ili ažurirati postojeći rekord, bez zadavanja vrednosti u toj koloni. To znači da će polja biti snimljena sa NULL vrednošću.
NULL vrednosti se tretiraju drugačije od ostalih vrednosti.
NULL se koristi kao mesto za nepoznate ili neprimenjive vrednosti.
NAPOMENA:
Nije moguće poređenje NULL i 0, ove vrednosti nisu ekvivalentne.
Ukoliko se pretpostavi ova "Persons" tabela:
P_Id | LastName | FirstName | Address | City |
---|---|---|---|---|
1 | Hansen | Ola | Sandnes | |
2 | Svendson | Tove | Borgvn 23 | Sandnes |
3 | Petterson | Kari | Stavanger |
Pretpostavlja se da je "Address" kolona u "Persons" tabeli opcionalna. Ukoliko se doda rekord bez vrednosti u "Address" koloni, "Address" kolona će biti snimljena sa NULL vrednošću.
Nije moguće testirati NULL vrednosti sa operatorima poređenja kao =, <, > ili <>.
Potrebno je upotrebiti "IS NULL" i "IS NOT NULL" operatore.
Za izbor samo rekorda sa NULL vrednostima u "Address" koloni je potrebno upotrebiti IS NULL operator.
SELECT LastName, FirstName, Address
FROM Persons
WHERE Address IS NULL
Result set će izgledati ovako:
LastName | FirstName | Address |
---|---|---|
Hansen | Ola | |
Petterson | Kari |
Za izbor rekorda bez NULL vrednosti, iskaz se piše kao:
SELECT LastName, FirstName, Address
FROM Persons
WHERE Address IS NOT NULL
Result set će izgledati ovako:
LastName | FirstName | Address |
---|---|---|
Svendson | Tove | Borgvn 23 |
Ukoliko se pretpostavi ova "Products" tabela:
P_Id | ProductName | UnitPrice | UnitsInStock | UnitsOnOrder |
---|---|---|---|---|
1 | Jarlsberg | 10.45 | 16 | 15 |
2 | Mascarpone | 32.56 | 23 | |
3 | Gorgonzola | 15.67 | 9 | 20 |
Pretpostavlja se nadalje da je "UnitsOnOrder" kolona opcionalna i može da sadrži NULL vrednosti.
Upotrebljava se sledeći SELECT iskaz:
SELECT ProductName, UnitPrice * (UnitsInStock + UnitsOnOrder)
FROM Products
U gornjem primeru ukoliko je vrednost bilo koje od "UnitsOnOrder" NULL rezultat je NULL.
Microsoftova ISNULL() funkcija se upotrebljava da se zada kako da se tretiraju NULL vrednosti.
NVL(), IFNULL() i COALESCE() funkcije mogu da se upotrebe da se postigne isti rezultat.
U ovom slučaju se želi da NULL vrednosti budu nula.
Niže ukoliko "UnitsOnOrder" je NULL neće naškoditi kalkulaciji jer ISNULL() vraća nulu ukoliko je vrednost NULL:
SELECT ProductName, UnitPrice*(UnitsInStock+IF(ISNULL(UnitsOnOrder),0,UnitsOnOrder))
FROM Products
SELECT ProductName,UnitPrice*(UnitsInStock+ISNULL(UnitsOnOrder,0))
FROM Products
Oracle nema ISNULL() funkciju. Uz NVL() funkciju se dobija isti rezultat:
SELECT ProductName,UnitPrice*(UnitsInStock+NVL(UnitsOnOrder,0))
FROM Products
MySQL poseduje ISNULL() funkciju. Radi malo drugačije od Microsoftove ISNULL() funkcije. U MySQL-u se može upotrebiti IFNULL() funkcija ovako:
SELECT ProductName,UnitPrice*(UnitsInStock+IFNULL(UnitsOnOrder,0))
FROM Products
ili se može upotrebiti COALESCE() funkcija ovako:
SELECT ProductName,UnitPrice*(UnitsInStock+COALESCE(UnitsOnOrder,0))
FROM Products
Tip podatka definiše koju vrstu vrednosti kolona može da sadrži.
Svaka kolona u tabeli baze podataka mora da ima ime i tip podataka.
SQL developeri trebaju da odluče koji tipovi podataka će biti smešteni unutar svake tabele i kolone kada se kreira SQL tabela. Tip podataka je oznaka i vodilja za SQL da zna koji tip podataka je očekivan unutar svake kolone i takođe identifikuje kako će SQL dejstvovati sa sačuvanim podacima.
Sledeća tabela prikazuje opšte tipove podataka u SQL-u:
Tip podatka | Opis |
---|---|
CHARACTER(n) | String sastavljen od karaktera, fiksne dužine n |
VARCHAR(n) ili CHARACTER VARYING(n) | String sastavljen od karaktera, promenljive dužine, najveća dužina n |
BINARY(n) | Binarni string, fiksne dužine n |
BOOLEAN | Čuva vrednosti TRUE ili FALSE |
VARBINARY(n) ili BINARY VARYING(n) | Binarni string, promenljive dužine, najveća dužina n |
INTEGER(p) | Ceo broj (bez decimala), preciznost p |
SMALLINT | Ceo broj (bez decimala), preciznost 5 |
INTEGER | Ceo broj (bez decimala), preciznost 10 |
BIGINT | Ceo broj (bez decimala), preciznost 19 |
DECIMAL(p,s) | Decimalni broj, p - broj cifara celog broja, s - broj cifara iza decimalnog simbola |
NUMERIC(p,s) | Decimalni broj, isti kao prethodni |
FLOAT(p) | Eksponencijalni oblik prikaza brojeva, osnova broja 10 i p je broj cifara mantise |
REAL | Broj, preciznost mantise 7 |
FLOAT | Broj, preciznost mantise 16 |
DOUBLE PRECISION | Broj, preciznost mantise 16 |
DATE | Čuva vrednosti godine, meseca i dana |
TIME | Čuva vrednosti sati, minuta i sekundi |
TIMESTAMP | Čuva vrednosti godine, meseca, dana, sati, minuta i sekundi |
INTERVAL | Uređen skup celih brojeva koji predstavljaju period vremena, zavisno od tipa intervala |
ARRAY | Uređen skup elemenata zadate dužine |
MULTISET | Neuređen skup elemenata promenljive dužine |
XML | Čuva XML podatke |
Različite baze podataka nude različit izbor za definisanje tipova podataka.
Naredna tabela prikazuje neke od zajedničkih imena tipova podataka od različitih platformi baza podataka:
Tip podatka | 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 |
Tipovi podataka mogu imati različita imena u različitim bazama podataka. Ukoliko je i ime isto veličina ili drugi detalji mogu da se razlikuju! Uvek proveriti dokumentaciju!
Tipovi podataka i opsezi za Microsoft Access, MySQL i SQL Server.
Tip podatka | Opis | Zauzima |
---|---|---|
Text | Karakteri (slova, brojevi i znaci) maksimalne dužine 255. | |
Memo | Memo se upotrebljava za veće količine teksta. Čuva do 65.536 karaktera. Memo polje se ne može sortirati, u njemu se može vršiti pretraga. | |
Byte | Dozvoljava cele brojeve između 0 i 255 | 1 byte |
Integer | Dozvoljava cele brojeve između -32.768 i 32.767 | 2 bytes |
Long | Dozvoljava cele brojeve između -2.147.483.648 i 2.147.483.647 | 4 bytes |
Single | Broj u tekućem zarezu. | 4 bytes |
Double | Broj u tekućem zarezu dvostruke preciznosti. | 8 bytes |
Currency | Upotrebljava se za novčane jedinice. Do 15 cifara za celobrojni deo, do 4 cifre za razlomljeni deo. Postoji mogućnost za izbor monete. | 8 bytes |
AutoNumber | AutoNumber polje dodeljuje automatski broj svakom rekordu. Obično počinje sa 1. | 4 bytes |
Date/Time | Upotrebljava se za datum i vreme. | 8 bytes |
Yes/No | Logičko polje može biti prikazano kao Yes/No, True/False ili On/Off. U kodu se upotrebljavaju konstante True i False (ekvivalenti -1 i 0). NULL vrednosti su zabranjene u ovom polju. | 1 bit |
Ole Object | Može da čuva slike, audio, video, ili druge BLOB-ove (Binary Large OBjects). | do 1GB |
Hyperlink | Sadrži linkove ka drugim fajlovima, uključujući i web strane. | |
Lookup Wizard | Dozvoljava upis opcija koje će se moći izabrati iz drop-down lista. | 4 bytes |
U MySQL-u postoje tri glavna tipa podataka: Text, Number i Date/Time.
Tip podatka | Opis |
---|---|
CHAR(size) | Čuva stringove (slova, brojevi i specijalni karakteri) zadate dužine. Dužina stringa je zadata u zagradi. Najveća dužina stringa je 255 karaktera. |
VARCHAR(size) | Čuva stringove (slova, brojevi i znaci) promenljive dužine. Dužina stringa je zadata u zagradi. Najveća dužina stringa je 255 karaktera. Ukoliko se unese više od 255 karaktera, konvertuje se u TEXT tip. |
TINYTEXT | Čuva stringove najveće dužine do 255 karaktera. |
TEXT | Čuva stringove najveće dužine do 65.535 karaktera. |
MEDIUMTEXT | Čuva stringove najveće dužine do 16.777.215 karaktera. |
LONGTEXT | Čuva stringove najveće dužine do 4.294.967.295 karaktera. |
BLOB | Za BLOBove (Binary Large OBjects). Čuva do 65.535 bajtova podataka. |
MEDIUMBLOB | Za BLOBove (Binary Large OBjects). Čuva do 16.777.215 bajtova podataka. |
LONGBLOB | Za BLOBove (Binary Large OBjects). Čuva do 4.294.967.295 bajtova podataka. |
ENUM(x,y,z,itd.) | Dozvoljava unos liste mogućih vrednosti. Može da se navede do 65.535 vrednosti u enum listu. Ukoliko se unese vrednost koja nije u listi prazna vrednost će biti umetnuta. Vrednosti su poređane po redosledu unosa. Moguće vrednosti se unose u sledećem formatu: ENUM('X','Y','Z'). |
SET | Sličan sa ENUM ali SET može da sadrži do 64 liste i da čuva više od jednog izbora. |
.
Tip podatka | Opis |
---|---|
TINYINT(size) | Celi brojevi između -128 i 127. Između 0 i 255 za UNSIGNED*. Broj cifara se može zadati u zagradi. |
SMALLINT(size) | Celi brojevi između -32.768 i 32.767. Između 0 i 65.535 za UNSIGNED*. Broj cifara se može zadati u zagradi. |
MEDIUMINT(size) | Celi brojevi između -8.388.608 i 8.388.607. Između 0 i 16.777.215 za UNSIGNED*. Broj cifara se može zadati u zagradi. |
INT(size) | Celi brojevi između -2.147.483.648 i 2.147.483.647. Između 0 i 4.294.967.295 za UNSIGNED*. Broj cifara se može zadati u zagradi. |
BIGINT(size) | Celi brojevi između -9.223.372.036.854.775.808 i 9.223.372.036.854.775.807. Između 0 i 18.446.744.073.709.551.615 za UNSIGNED*. Broj cifara se može zadati u zagradi. |
FLOAT(size,d) | Broj u tekućem zarezu. Najveći broj cifara je zadat parametrom size. Najveći broj cifara sa desne strane decimalnog zareza je zadat d parametrom. |
DOUBLE(size,d) | Broj u tekućem zarezu dvostruke preciznosti. Najveći broj cifara je zadat parametrom size. Najveći broj cifara sa desne strane decimalnog zareza je zadat d parametrom. |
DECIMAL(size,d) | DOUBLE sačuvan kao string sa dozvoljenim fiksiranim decimalnim znakom. Najveći broj cifara je zadat parametrom size. Najveći broj cifara sa desne strane decimalnog zareza je zadat d parametrom. |
* Integer tip ima posebnu opciju koja se zove UNSIGNED. U normalnom slučaju integer počinje od negativne vrednosti i ide do pozitivne vrednosti. Dodavanjem UNSIGNED atributa taj opseg se pomera nagore, počinje od nule i ne sadrži negativne brojeve.
Tip podatka | Opis |
---|---|
DATE() | Datum formata: YYYY-MM-DD. Podržani period je između '1000-01-01' i '9999-12-31'. |
DATETIME() | * Kombinacija datuma i vremena formata: YYYY-MM-DD HH:MI:SS Podržani period je između '1000-01-01 00:00:00' i '9999-12-31 23:59:59'. |
TIMESTAMP() | * Vremenski pečat. TIMESTAMP vrednosti se čuvaju kao broj sekundi od početka Unix epohe ('1970-01-01 00:00:00' UTC). Format: YYYY-MM-DD HH:MI:SS. Podržani period je između '1970-01-01 00:00:01' UTC i '2038-01-09 03:14:07' UTC. |
TIME() | Vreme formata: HH:MI:SS. Podržani period je između '-838:59:59' i '838:59:59'. |
YEAR() | Godina u dvocifrenom ili četvorocifrenom formatu. Vrednosti podržane u četvorocifrenom formatu su između 1901 i 2155, vrednosti podržane u dvocifrenom formatu su između 70 i 69, predstavljajući godine od 1970 do 2069. |
* Čak iako DATETIME i TIMESTAMP vraćaju isti format rade veoma različito. Pri izvršenju INSERT ili UPDATE query-ja TIMESTAMP se automatski prepodešava na sadašnji datum i vreme. TIMESTAMP takođe prihvata različite formate kao: YYYYMMDDHHMISS, YYMMDDHHMISS, YYYYMMDD ili YYMMDD.
U SQL Serveru postoje četiri glavna tipa podataka: String, Number, Date/Time i ostali.
Tip podatka | Opis | Zauzima |
---|---|---|
char(n) | Čuva stringove (slova, brojevi i specijalni karakteri) zadate dužine. Dužina stringa je zadata u zagradi. Najveća dužina stringa je 8.000 karaktera. | Zadata dužina |
varchar(n) | Čuva stringove (slova, brojevi i specijalni karakteri) promenljive dužine. Dužina stringa je zadata u zagradi. Najveća dužina stringa je 8.000 karaktera. | 2 bajta + broj karaktera |
varchar(max) | Čuva stringove (slova, brojevi i specijalni karakteri) promenljive dužine. Najveća dužina stringa je 1.073.741.824 karaktera. | 2 bytes + broj karaktera |
text | Čuva stringove (slova, brojevi i specijalni karakteri) promenljive dužine. Dozvoljeni kapacitet je 2GB tekstualnih podataka. | 4 bytes + broj karaktera |
nchar | Unicode string zadate najveće dužine od 4.000 karaktera. | Zadata dužina x2 |
nvarchar | Unicode string promenljive dužine. Najveće dužina je 4.000 karaktera. | |
nvarchar(max) | Unicode string promenljive dužine. Najveće dužina je 536.870.912 karaktera. | |
ntext | Unicode string promenljive dužine. Dozvoljeni kapacitet je 2GB tekstualnih podataka. | |
bit | Dozvoljava 0, 1 ili NULL. | |
binary(n) | Binarni string zadate dužine. Dozvoljeni kapacitet je do 8.000 bajtova. | |
varbinary | Binarni string promenljive dužine. Dozvoljeni kapacitet je do 8.000 bajtova. | |
varbinary(max) | Binarni string promenljive dužine. Dozvoljeni kapacitet je do 2GB. | |
image | Binarni string promenljive dužine. Dozvoljeni kapacitet je do 2GB. |
.
Tip podatka | Opis | Zauzima |
---|---|---|
tinyint | Dozvoljava cele brojeve između 0 i 255 | 1 bajt |
smallint | Dozvoljava cele brojeve između -32.768 i 32.767 | 2 bajta |
int | Dozvoljava cele brojeve između -2.147.483.648 i 2.147.483.647 | 4 bajta |
bigint | Dozvoljava cele brojeve između -9.223.372.036.854.775.808 i 9.223.372.036.854.775.807 | 8 bajta |
decimal(p,s) | Dozvoljava brojeve između -1038+1 i 1038–1. Parametar p zadaje ukupan broj cifara (sa leve i desne strane decimalnog znaka). Vrednost p je između 1 i 38. Podrazumevana vrednost je 18. Parametar s zadaje maksimalni broj cifara sa desne strane decimalnog znaka. Vrednost s mora da bude između 0 i p. Podrazumevana vrednost je 0. | 5-17 bajtova |
numeric(p,s) | Dozvoljava brojeve između -1038+1 i 1038–1. Parametar p zadaje ukupan broj cifara (sa leve i desne strane decimalnog znaka). Vrednost p je između 1 i 38. Podrazumevana vrednost je 18. Parametar s zadaje maksimalni broj cifara sa desne strane decimalnog znaka. Vrednost s mora da bude između 0 i p. Podrazumevana vrednost je 0. | 5-17 bajtova |
smallmoney | Novčani podatak između -214.748,3648 i 214.748,3647 | 4 bajta |
money | Novčani podatak između -922.337.203.685.477,5808 i 922.337.203.685.477,5807 | 8 bajtova |
float(n) | Broj u tekućem zarezu između -1.79E+308 i 1.79E+308. Parametar n zadaje da li će polje zauzimati 4 ili 8 bajtova. Ukoliko se zada float(24) polje će zauzimati 4 bajta, ukoliko se zada float(53) zauzimaće 8 bajtno polje. Podrazumevana vrednost za n je 53. | 4 ili 8 bajtova |
real | Broj u tekućem zarezu između -3.40E+38 i 3.40E+38 | 4 bajta |
.
Tip podatka | Opis | Zauzima |
---|---|---|
datetime | Od 1. januara 1753. do 31. decembra 9999. sa tačnošću od 3.33 milisekunde. | 8 bajtova |
datetime2 | Od 1. januara 0001. do 31. decembra 9999. sa tačnošću od 100 nanosekundi. | 6-8 bajtova |
smalldatetime | Od 1. januara 1900. do 6. juna 2079. sa tačnošću od 1 minuta. | 4 bajtova |
date | Čuva samo datume od 1. januara 0001. do 31. decembra 9999. | 3 bajta |
time | Čuva samo vreme sa tačnošću od 100 nanosekundi. | 3-5 bajtova |
datetimeoffset | Isto kao i datetime2 sa dodatom mogućnošću za podešavanje vremenske zone. | 8-10 bajtova |
timestamp | Čuva jedinstveni broj koji se osvežava kada se rekord kreira ili modifikuje. Vrednost se zasniva na intervalu sata i ne odgovara realnom vremenu. Tabela može da poseduje samo jedno polje tipa podatka timestamp. |
.
Tip podatka | Opis |
---|---|
sql_variant | Čuva najviše do 8.000 bajtova podataka različitog tipa, osim tipova podataka text, ntext, and timestamp. |
uniqueidentifier | Čuva podatak o globally unique identifier (GUID) identifikatoru. |
xml | Čuva XML format podataka. Dozvoljeni kapacitet je 2GB. |
cursor | Čuva upućivanje na kursor koji se upotrebljava za operacije nad bazom podataka. |
table | Čuva result set za kasniju obradu. |