SQL naredbe za manipulaciju podacima

Naredbe za manipulaciju podacima su, u stvari, najkorišćenije naredbe u SQL-u. Ako ste se ikada susreli sa ovim jezikom (pre ovog kursa), verovatno je bilo baš kroz ovaj set naredbi.

Osnovne manipulacione SQL naredbe su SELECT, INSERT, UPDATE i DELETE.

SELECT naredba

Select naredba je naredba koja emituje tabelarni rezultat na osnovu unetih parametara:

select ‘pozdrav’

Emituje reč pozdrav prikazanu tabelarno.

Iz primera možemo zaključiti da SELECT, iako se često koristi za prikazivanje podataka, nije zadužena za logiku preuzimanja tih podataka, već samo za njihov prikaz. Samu logiku obavlja izraz koji sledi iza naredbe.

(Za sledeći primer pristupite bazi classicmodels (use classicmodels))

select * from customers

Ako je sve u redu, primer bi trebalo da emituje sve podatke tabele customers.

Vidimo iz ova dva primera da naredba SELECT može rukovati sa podacima iz nekog izvora ili podacima kreiranim direktno u kodu, pa čak i u samoj naredbi:

set @a=10;
select @a;

(Obratite pažnju, primer ima više linija. Ne može biti startovan u Query pretraživaču, pa morate pokušati sa drugim alatom. Npr. MySQL monitoru)

Ovaj primer prikazuje vrednost prethodno definisane promenljive a. Podaci ne dolaze iz same baze, već se generišu u memoriji. Rezultat će biti:

+------+
| @a   |
+------+
|  10  |
+------+

Naslov tabele je @a a vrednost polja 10. Ali, naslov tabele možemo formatirati i sami:

select ‘Pozdrav’ as ‘pozdravna poruka’

Ovaj primer daje rezultat:

+------------------+
| pozdravna poruka |
+------------------+
| Pozdrav          |
+------------------+

Naredba SELECT može i kao parametar prihvatiti neku operaciju ili funkciju:

select 2+3;

+-----+
| 2+3 |
+-----+
|  5  |
+-----+

ili

select ceil(2.8)

+-----------+
| ceil(2.8) |
+-----------+
|       3   |
+-----------+

Videli smo da SELECT naredba ima dva dela. Samu naredbu i polja (sa vrednostima).

SELECT može takođe posedovati i treći deo, a to je izvor podataka. Preuzimanje rezulata iz izvora podrazumeva i ključnu reč from, kojoj sledi izvor (tabela):

select * from products

Ovaj upit vraća sve redove i sve kolone tabele products, što je veoma retko rezultat koji želimo. Najčešće će nam biti potrebni samo određeni podaci iz izvora, zbog čega pribegavamo filtraciji upita.

Ovu filtraciju možemo uraditi na mnogo polja i načina. Pre svega, možemo filtrirati sam format izlaza.  Na primer, ne želimo sve kolone iz prethodnog primera, već samo kolone productname i buyprice (naziv i cenu proizvoda). Evo upita:

select productname, buyprice from products

Ili, želimo da filtriramo po redovima, tako što ćemo emitovati samo redove sa proizvodima u kojima je cena veća od 100 (valuta je nebitna):

select productname, buyprice from products where buyprice > 100

Upoznali smo još jednu ključnu reč. Where. Ova ključna reč očekuje uslovni izraz, poput izraza iz primera (buyprice > 100).

Ali tu se lista parametara SELECT naredbe ne mora završiti. Moguće je dati i dodatne zahteve SELECT naredbi. Na primer, kako će podaci u rezultatu biti sortirani.

Ako izvršimo dosadašnji upit, dobićemo sledeći rezultat:

‘1962 LanciaA Delta 16V’, 103.42
‘1998 Chrysler Plymouth Prowler’, 101.51

To jesu proizvodi čija je cena veća od 100. Ali, recimo da želimo da lista bude sortirana od najmanje cene. Dodaćemo još jednu ključnu reč. Order by:

select productname,buyprice from products where buyprice > 100 order by buyprice

Rezultat će sada biti dobro sortiran.

Verovatno se pitate kako to da je MySQL znao da baš treba da sortira navedenu kolonu od manje vrednosti ka većoj? Zapravo i nije. Podrazumevano sortiranje, prilikom upotrebe ključne reči order by, je sortiranje od manje vrednosti ka većoj i ukoliko želimo da to sortiranje bude obrnuto (od veće vrednosti ka manjoj), moramo to eksplicitno naglasiti. Za to koristimo ključne reči DESC (od većeg ka manjem) i ASC (od manjeg ka većem). Ceo upit sada izgleda ovako:

select productname,buyprice from products where buyprice > 100 order by buyprice desc

Slika 1

Slika 1

 

Često ćemo, u uslovnom izrazu, koristiti više od jednog uslova, povezane logičkim operatorima. Na primer, ako bismo želeli da vidimo sva vozila čija je cena veća od 100, a stok veći od 6000. Mogli bismo proširiti uslovni izraz:

select productname,buyprice,quantityinstock from products where buyprice > 100 and quantityinstock>6000

U uslovni izraz čak možemo staviti i sam upit:

select productname,buyprice,quantityinstock from products where buyprice > (select 100)

Primer je banalan, ali neki ozbiljniji primer bi bio isuviše komplikovan u ovom trenutku. Bitno je shvatiti da je select 100 u zagradi jedan potpuno drugi upit, čiji rezultat se koristi za poređenje. S obzirom na to da upit nema veze sa spoljnim upitom, on spada u tip nekorelisanih upita (Non-Corelated), dok bi, da je zahtevao vrednost iz glavnog upita za sopstvenu izgradnju, bio korelisan (Corelated).

Treba paziti prilikom korišćenja podupita. U ovom slučaju, uslov zahteva jedan broj za poređenje, što naš upit (select 100) i vraća. Ali, kada unutrašnji upit ne bi vraćao samo jedan rezultat (skalarnu vrednost), ceo upit bi prikazao grešku.

Spajanje tabela

U abecedi SQL upita, spajanje tabela je slovo B. Nakon poznavanja osnove upitne sintakse, ovo je svakako sledeća oblast koju treba preći.

Ukoliko unesete sledeća dva upita:

select * from orderdetails

i

select * from products

Videćete da se u rezultatu oba upita nalazi jedna zajednička kolona: productCode. Ako se podsetimo prethodnih lekcija, u kojima smo obrađivali strane ključeve, setićemo se da je ovo kolona koja povezuje redove jedne tabele sa redovima druge.

Za svaki red tabele orderdetails, postoje neke stvari koje se pamte u bazi. Pre svega, broj proizvoda, a zatim i količina proizvoda poručenih pod tim brojem, pa je tako ova tabela povezana sa proizvodima.

Takođe, tabela je povezana i sa tabelom orders, jer poseduje i kolonu orderNumber. Na taj način, ostvaruje se standardna N:N relacija između proizvoda i porudžbina.

Ostaje problem preuzimanja podataka iz tako spojenih tabela. I on se može rešiti na dva načina. Recimo da želimo da preuzmemo sve detalje jedne porudžbine.

Prvi, lošiji način je, korišćenje uslovnog izraza:

select * from orderdetails where ordernumber = 10100

Ovaj upit nam je već poznat. Funkcioniše samo sa jednom tabelom, jer već unapred znamo broj porudžbine (10100). Ali, to je ujedno i jedini podatak vezan za porudžbinu koji se nalazi u tabeli orderdetails. Šta ako, na primer, znamo samo broj korisnika (na primer 121) i datum porudžbine (2003-01-29):

select * from orders where customernumber = ‘121’ and orderdate = ‘2003-01-29 00:00:00’

Ovaj upit će nam dati sve pošiljku u kojoj je broj korisnika 121 (osim ukoliko korisnik nije poručivao više u jednom danu). Ali, u ovoj porudžbini može biti jedan ili više proizvoda. Kako da znamo koje proizvode tačno sadrži?

Malopre smo videli kako da dođemo do svih detalja (koji sadrže i broj proizvoda) jedne porudžbine. Treba nam njen broj. A broj smo takođe dobili u prethodnom upitu. Dakle, ove upite samo treba postaviti jedan u drugi:

select * from orderdetails where ordernumber = (select ordernumber from orders where customernumber = ‘121’ and orderdate = ‘2003-01-29 00:00:00’)

Obratite pažnju da podupit koji preuzima broj porudžbine više nije select * from orders.. već select ordernumber from, jer bi, u suprotnom, bila vraćena vrednost sa više kolona, što glavni upit ne bi bio u stanju da prihvati. Ovaj upit ima identičan rezultat kao da smo u uslov upisali sam broj:

select * from orderdetails where ordernumber = (10103)

ili

select * from orderdetails where ordernumber = (select 10103)

Doduše, ovo ne važi i za sam server. Mehanizam skladištenja će ipak malo više morati da se pomuči prilikom izvršavanja upita, nego prilikom prihvatanja već pripremljene vrednosti. To je, na ovako maloj količini podataka trivijalno, ali na nekoj većoj količini, ovakav pristup može izazvati znatna usporenja.

Mi smo ograničili broj porudžbina jednog kupca, unosom posebnog datuma. Na taj način smo dobili samo jedan red, odnosno samo jedan broj porudžbine. Šta ako bismo želeli da vidimo sve proizvode, svih porudžbina jednog kupca? U tom slučaju, za početak potrebna bi nam bila lista svih porudžbina:

select ordernumber from orders where customernumber = 121

Rezultat upita je lista od četiri reda, koje nekako treba da postavimo kao uslov u orderdetails tabeli. Za to možemo iskoristiti operator IN.

Pogledajmo kako se koristi:

select * from orderdetails where ordernumber in (select ordernumber from orders where customernumber = 121)

Ovaj upit je sličan malopređašnjem, osim što smo, umesto jednakosti, upotrebili operator in. Zbog toga, sada nismo više ograničeni na jednu, već na više vrednosti. Ovaj upit daje identičan rezultat kao da smo napisali i:

select * from orderdetails where ordernumber in (10103,10158,10309,10325)

Naravno, identičnost važi za rezultat. Performanse će, naravno, biti bolje ukoliko server ne mora da dolazi do vrednosti podupitom.

U svim slučajevima, imamo kao rezultat detalje porudžbine. To je dobar rezultat, jer za svaki detalj porudžbine postoji samo po jedan proizvod. To znači da mi imamo listu svih proizvoda, samo je potrebno da je izfiltriramo. Za početak, izmenićemo upit tako da prikazuje samo broj proizvoda:

select productcode
from orderdetails
where ordernumber in (select ordernumber from orders where customernumber = 121)

Pretpostavimo sada da mi, zapravo, ne želimo brojeve proizvoda (što je i logično), već želimo njihove nazive, pri čemu bi bilo dobro da imamo i cene. Ovo je sada jednostavno. Nećemo uraditi ništa što do sada već nismo.

Napravićemo upit koji izlistava željene podatke o proizvodima, ali po zadatom kriterijumu (productcode), koji ćemo proslediti uz pomoć prethodnog upita.

select productname, buyprice  from products
where productcode in (
select productcode
from orderdetails
where ordernumber in (select ordernumber from orders where customernumber = 121)
)
Ovaj upit će dati dobre rezultate. Dobićemo listu naših proizvoda, ali se ovo rešenje iz više razloga nije dobro. Nepregledno je i sporo.

Zbog toga se, za spajanje tabela, mnogo češće koriste takozvani join-ovi.

join je ključna reč u SQL-u, koja označava spoj između dve tabele. Ova ključna reč nikada se ne pojavljuje sama, već obavezno dolazi u kompletu sa ključnom rečju ON (ali često i nekim drugim ključnim rečima). Pogledajmo konverziju prethodnog primera u vezi sa povezivanjem  za korišćenje JOIN-a.

Prilikom pisanja JOIN upita najbolje je početi od tabele čija su nam polja zapravo potrebna. U ovom slučaju, to su nazivi i cene proizvoda. Dakle:

select productname, buyprice from products

Naravno, ovaj upit vraća sve proizvode. U ovom trenutku nije nam bitno da filtriramo podatke, već samo da ih povežemo. Pogledajmo sintaksu za povezivanje:

select productname, buyprice
from products join orderdetails on products.productcode = orderdetails.productcode

Upit je prilično običan, sve do pojave ključne reči JOIN. Kada se pojavi ključna reč JOIN, podrazumeva se da sa njene leve i desne strane stoje nazivi tabela koje se spajaju (u ovom slučaju products i orderdetails). Zatim sledi ključna reč on i polje po kome će biti spojene. Primećujemo da oba polja sadrže naziv tabele i naziv kolone. To je veoma važno, jer se može desiti da obe tabele poseduju istoimene kolone (kao u primeru) i u tom slučaju, server ne može da identifikuje ciljnu kolonu, pa dolazi do greške.

Startovanjem ovog upita dobićemo sve proizvode svih detalja porudžbine, što naravno, nećemo, ali ćemo taj deo ostaviti za kasnije. Sada, ćemo povezati ove dve tabele sa tabelom orders, na potpuno isti način:

select productname, buyprice
from products join orderdetails on products.productcode = orderdetails.productcode
join orders on orders.ordernumber = orderdetails.ordernumber

Sada u rezultatu imamo sve potrebne podatke, samo je potrebno da ih izfiltriramo. Te podatke možemo i videti ukoliko izmenimo deo upita (productname, buyprice) sa oznakom *

Ako to uradimo, videćemo da naš rezultat ima veliki broj kolona (sve kolone svih spojenih tabela).

Pošto su podaci tu, ostaje samo da uradimo filtraciju:

select productname, buyprice
from products join orderdetails on products.productcode = orderdetails.productcode
join orders on orders.ordernumber = orderdetails.ordernumber
where orders.customernumber = 121

Verovatno i ne treba pominjati da je ovaj pristup daleko elegantniji i brži od prethodnog.

U primeru, polja koja smo želeli da vidimo u rezultatu su: productname i buyprice. Zahvaljujući tome što ta polja postoje samo u tabeli products, nije došlo do greške. U suprotnom, greška bi se dogodila. Zbog toga i u samoj listi polja za rezultat, treba pravilno adresirati željenu kolonu (tabela.kolona).

Kada jednom postavimo join upit, lako ga je nadograditi sa novim tabelama. Na primer, ako bismo želeli da vidimo i naziv kupca, koji se nalazi u customers tabeli, mogli bismo jednostavno dodati još jedan join:

select productname, buyprice, customers.customername
from products join orderdetails on products.productcode = orderdetails.productcode
join orders on orders.ordernumber = orderdetails.ordernumber
join customers on orders.customernumber = customers.customernumber
where orders.customernumber = 121

Spoljni JOIN-ovi

Kada upotrebimo ključnu reč JOIN, podrazumevano je da spajanje bude tzv. unutrašnje. To znači da će se u rezultatu pojaviti samo redovi koji imaju validne spojeve na obe strane.

Za primer, napravićemo dve tabele:

create table spojeviLevo (id int primary key auto_increment, ime varchar(50));
create table spojeviDesno (id int primary key auto_increment, prezime varchar(50));
insert into spojevidesno (prezime) values (‘jovanovic’),(‘petrovic’);
insert into spojevilevo (ime) values (‘jovan’),(‘petar’), (‘zoran’);

Sada, ako pokušamo da spojimo tabele sledećim upitom:

select * from spojevilevo join spojevidesno on spojevilevo.id = spojevidesno.id

kao rezultat, dobićemo dva reda:

+----+-------+----+-----------+
| id | ime   | id | prezime   |
+----+-------+----+-----------+
|  1 | jovan |  1 | jovanovic |
|  2 | petar |  2 | petrovic  |
+----+-------+----+-----------+

iako tabela spojevilevo ima tri reda (još jedan red sa imenom zoran).

Kada uradimo INNER JOIN (to je podrazumevani tip JOIN-a kada ne stavimo ni jedna drugi parametar) SQL uzima u obzir samo one redove za koje postoji veza. Pošto u tabeli spojevilevo postoji id koji ne postoji u tabeli spojevidesno, JOIN je višak redova ne uzima u obzir.

Ovo se može prevazići spoljašnjim spojem (outer JOIN):

select * from spojevilevo left join spojevidesno on spojevilevo.id = spojevidesno.id

ili

select * from spojevilevo left outer join spojevidesno on spojevilevo.id = spojevidesno.id

Ova dva upita imaju identičan rezultat, jer, onog trenutka kada postavimo ključnu reč left ili right, SQL podrazumeva da je u pitanju outer join (spoljašne spajanje).

Rezultat upita je:

+----+-------+------+-----------+
| id | ime   | id   | prezime   |
+----+-------+------+-----------+
|  1 | jovan |    1 | jovanovic |
|  2 | petar |    2 | petrovic  |
|  3 | zoran | NULL | NULL      |
+----+-------+------+-----------+

Vidimo da su nedostajeće tabele ispunjene null vrednostima (nema vrednost).

Sama ključna reč left, odnosi se na položaj tabele u spoju i osim nje, SQL poznaje (logično) i reč right kao „prekidač“. Pošto je položaj tabela u spoju (spojevilevo left join spojevidesno) takav da je tabela spojevilevo sa leve strane, SQL tu tabelu izlistava celu. Da je spoj bio right, spoj bi se izvršavao sa desne strane (tabela spojevidesno) i red sa imenom zoran ne bi bio uzet u obzir.

Osim unutrašnjeg i spoljašnjeg, postoji i ukršteno spajanje (cross JOIN). Ovo spajanje podrazumeva kombinacije svih spojeva, i daje obično velike rezultate. Ovu vrstu spajanja mnogo ređe koristimo od unutrašnjih i spoljašnjih:

select * from spojevilevo cross join spojevidesno

Limit i distinct

Iako su ove ključne reči samo još dva opciona prekidača za select upite, izuzetno su važni za dobijanje efikasnih rezultata, zato ih stavljamo u zaseban pasus:

Limit koristimo ukoliko želimo da ograničimo broj redova u rezultatu. Jednostavno zvuči, a još jednostavnije funkcioniše:

Ako izvršimo sledeći upit, on će emitovati 122 reda:

select * from customers

Recimo da hoćemo samo 10 redova. Upit će glasiti:

select * from customers limit 10

Distinct koristimo ako hoćemo da spojimo identične redove koji se ponavljaju u jedan red. Na primer, sledeći upit:

select status from orders

Vraća 326 redova sa vrednostima shipped, cancelled, resolved, on hold, disputed i in process.

Ali upit:

select distinct status from orders

vraća samo 6 redova, jer toliko zapravo ima unikatnih vrednosti u njima.

Grupisanje

Problem kod grupisanja je što je blisko vezano za agregatne funkcije, koje još uvek nećemo raditi. Zato ćemo samo pomenuti i ovu komponentu, kako bismo razumeli sistem funkcionisanja, a posle je aktivnije isprobati u radu sa funkcijama.

Grupisanje omogućava grupisanje redova u celine po zadatom kriterijumu. Na primer, pogledajmo sledeći upit:

select * from orderdetails

Vidimo da postoje različite porudžbine, sa različitim proizvodima. Ali, takođe, vidimo da se brojevi porudžbina ponavljaju. Šta ako bismo želeli da dobijemo ukupan broj poručenih proizvoda za svaku porudžbinu. Mogli bismo napisati:

select ordernumber, sum(quantityordered) from orderdetails group by ordernumber

MySQL će sabrati (funkcija sum()) sve količine u porudžbinama koje imaju isti broj.

INSERT naredba

Podatke takođe možemo i uneti u bazu. Za to koristimo naredbu INSERT. Njena osnovna sintaksa je sledeća:

insert into mojatabela (kolona1,kolona2…) values (vrednost1,vrednost2…)

Evo kako bi to izgledalo na primeru unosa reda u tabelu orders:

insert into orders (ordernumber,orderdate,requireddate,shippeddate,status,comments,customernumber)
values
(5000,curdate(),curdate(),curdate(),’Shipped’,’probna porudzbina’, 121)

Ukoliko podaci koje unosimo prate broj i pozicije kolona tabele, onda ne moramo eksplicitno naglašavati kolone:

insert into orders values (5001,curdate(),curdate(),curdate(),’Shipped’,’probna porudzbina’, 121)

Ponekad čak ne moramo ni to, već je dovoljno eksplicitno naglasiti samo kolonu koju hoćemo da ispunimo:

insert into mojatabela (prezime) values (‘petrovic’)

Ali u tom slučaju, kolone koje smo izostavili moraju imati jednu od dve osobine. Ili mogućnost prihvatanja Null vrednosti ili podrazumevanu vrednost.

U sledećem primeru kreirana je tabela sa podrazumevanom vrednošću za kolonu ime, što omogućava izvršenje prethodnog upita:

create table mojatabela
(
id int primary key auto_increment,
ime varchar(50) default ‘podrzumevano ime’,
prezime varchar(50)
)

Moguć je unos i više redova u jednom upitu:

insert into mojatabela (prezime) values (‘petrovic’),(‘jovanovic’),(‘nikolic’)

DELETE naredba

Ovo je najjednostvnija manipulaciona naredba. Jednostavno, ako napišemo:

delete from mojatabela

obrisaćemo sadržaj tabele.

Naravno, ovo nema nikakvu svrhu bez filtracije, pa ćete naredbu delete najčešće (uvek) koristiti sa filtracijom:

delete from mojatabela where id=10

ili

delete from mojatabela where id between 10 and 20

Prvi put se srećemo sa ključnom rečju between. Njena primena je jasna – prikazuje sve vrednosti koje su unutar zadatog uslova (10 i 20), uključujući i same vrednosti iz uslova. Dakle, identično sledećem:

delete from mojatabela where id >= 10 and id <=20

Na početku pasusa pomenuli smo naredbu delete from mojatabela, koja briše celu tabelu. Ovde postoji jedan problem, pa moramo skrenuti pažnju.

Kada tabela poseduje auto_increment kolonu (ili identifikacionu kolonu), inkrementaciona vrednost koju generiše server, nikada se ne vraća unazad. Što znači, ako smo unosili redove koji su imali generisane vrednosti 1,2,3,4,5,6…. a zatim obrisali neki od tih redova (npr. red broj 3), lista će imati sledeće redove: 1,2,4,5,6. Sledećem unešenom redu, server neće dodeliti vrednost 3 (što bi bilo logično, jer ta vrednost sada ne postoji), već 7, jer je to zapravo naredna vrednost u auto inkrementaciji.

To znači da, kada imamo tablu sa, na primer, poslednjom auto inkrementiranom vrednošću 1000, i izvršimo naredbu DELETE nad celom tabelom, a zatim napravimo novi unos naredbom insert, vrednost auto inkrementirane kolone biće 1001, iako će unešena vrednost biti jedina u tabeli.

Poslednju unetu auto_increment vrednost, možemo dobiti funkcijom last_insert_id()

Ovo možemo izbeći naredbom TRUNCATE, koja takođe briše sadržaj tabele, ali pri tom resetuje i brojač auto inkrementacione kolone:

truncate table mojatabela

Obratite samo pažnju kada koristite TRUNCATE. Ova naredba, za razliku od naredbe DELETE nije logovana naredba. To znači da, ukoliko budete morali da vršite povraćaj baze, ova naredba neće biti zabeležena.

UPDATE naredba

Naredba update služi za ažuriranje određenog ili određenih redova. Njena sintaksa je, kao što smo rekli, prilično jednostavna:

update mojatabela set prezime = ‘petrovic’

ili

update mojatabela set ime = ‘petar’, prezime = ‘petrovic’

Bilo koji od ova dva upita izmeniće sve redove u tabeli, što najčešće, nije ono što želimo. Kao i za naredbu DELETE i za UPDATE, skoro uvek će nam biti potrebna filtracija:

update mojatabela set ime = ‘petar’, prezime = ‘petrovic where id=10

ili

update mojatabela set ime = ‘petar’, prezime = ‘petrovic where ime=’jovan’ and prezime = ‘jovanovic’

Ovde ćemo završiti priču o manipulacionim naredbama. Iako je lekcija dugačka, znajte da smo samo dotakli ovu tematiku i da su informacije sadržane na prethodnim stranama minimum znanja koji je neophodno da posedujemo da bismo uradili bilo šta u SQL-u.

Manipulacija podacima je osnovna tačka kontakta između nas, kao korisnika i baze i zato ovu lekciju shvatite ozbiljno i ako je potrebno, obradite je i više puta.

Najvažnije iz lekcije:

  1. Manipulacione naredbe su SELECT, INSERT, UPDATE i DELETE.
  2. Naredba SELECT prikazuje tabelarni rezultat u zavisnosti od parametara.
  3. Naredba INSERT unosi vrednosti u tabelu.
  4. Naredba UPDATE menja vrednosti u tabeli.
  5. Naredba DELETE briše vrednosti iz tabele.
  6. ključna reč where počinje uslovni izraz upita.
  7. ključna reč join spaja dve tabele u jednom upitu.
  8. ključna reč order by sortira rezultate dobijene naredbom SELECT.
  9. ključna reč group by služi za grupisanje određenih redova rezultata.

Naredbe za manipulaciju – Vežbe


 

Vežba 1

Problem:

Potrebno je kreirati bazu podataka application_07. U ovoj bazi treba kreirati tabelu users, koja sadrži tri kolone id, name i password.

Potrebno je uneti tri korisnika u ovu tabelu (Peter – sa šifrom 123, Jenny – sa šifrom 345 i John – sa šifrom 678)

Rešenje:

create database application_07;
use application_07;
create table users ( id int primary key auto_increment, name varchar(50), password varchar(15) );
insert into users (name, password) values (‘Peter’,’123′),(‘Jenny’,’345′),(‘John’,’567′);


 

Vežba 2

Problem:

Za prethodno kreiranu tabelu (users), potrebno je kreirati upit za preuzimanje podataka. Treba preuzeti sve podatke o korisnicima čije ima počinje slovom j.

Rešenje:

select * from users where name like ‘j%’;


 

Vežba 3

Problem:

Za tabelu users, potrebno je napraviti upit koji vraća sve korisnike čiji je ID veći od jedan i manji od pet

Rešenje:

select * from users where id > 1 and id < 5;


 

Vežba 4

Problem:

Treba napraviti još jednu tabelu u bazi application_07. Tabela se zove statuses i sadrži dva polja, ID i name. Potrebno je dodati tri naziva statusa u ovu tabelu. User, administrator i superadministrator.

Treba izmeniti postojeću tabelu users, dodavanjem još jedne kolone. Naziv kolone je status.

Rešenje:

create table statuses ( id int primary key auto_increment, name varchar(30) );

insert into statuses (name) values (‘user’);
insert into statuses (name) values (‘administrator’);
insert into statuses (name) values (‘superadministrator’);

alter table users add column status int;


 

Vežba 5

Problem:

U tabeli users dodeliti statuse korisnicima, tako da John bude administrator, Jenny superadministrator a Peter user.

Rešenje:

update users set status = 2 where name = ‘john’;
update users set status = 3 where name = ‘jenny’;
update users set status = 1 where name = ‘peter’;


 

Vežba 6

Problem:

Potrebno je prikazati ime i naziv statusa korisnika sa ID-om 2

Rešenje:

select users.name, statuses.name from users join statuses on users.status = statuses.id where users.id = 2;

Tutorijali - Materijali za učenje

Pretraga

_Edukacija_300x250px
baner-edukacija