Język zapytań SQL

CREATE DATABASE szkola
DEFAULT CHARACTER SET utf8mb4
DEFAULT COLLATE utf8mb4_polish_ci;

USE szkola;

CREATE TABLE klasy (
id_klasy   INT AUTO_INCREMENT PRIMARY KEY,
nazwa      VARCHAR(5) NOT NULL UNIQUE,
profil     VARCHAR(40),
wychowawca VARCHAR(60)
);

CREATE TABLE uczniowie (
id_ucznia       INT AUTO_INCREMENT PRIMARY KEY,
imie            VARCHAR(30) NOT NULL,
nazwisko        VARCHAR(50) NOT NULL,
data_urodzenia  DATE,
email           VARCHAR(80) UNIQUE,
id_klasy        INT,
FOREIGN KEY (id_klasy) REFERENCES klasy(id_klasy)
);

CREATE TABLE przedmioty (
id_przedmiotu  INT AUTO_INCREMENT PRIMARY KEY,
nazwa          VARCHAR(50) NOT NULL,
liczba_godzin  INT DEFAULT 0
);

CREATE TABLE oceny (
id_oceny       INT AUTO_INCREMENT PRIMARY KEY,
id_ucznia      INT NOT NULL,
id_przedmiotu  INT NOT NULL,
ocena          DECIMAL(2,1) NOT NULL,
waga           INT DEFAULT 1,
data_wpisu     DATE,
FOREIGN KEY (id_ucznia)     REFERENCES uczniowie(id_ucznia),
FOREIGN KEY (id_przedmiotu) REFERENCES przedmioty(id_przedmiotu)
);

-- 1. dodanie kolumny na numer telefonu
ALTER TABLE uczniowie ADD COLUMN telefon VARCHAR(15);

-- 2. zmiana typu istniejącej kolumny (nazwisko na dłuższe)
ALTER TABLE uczniowie MODIFY COLUMN nazwisko VARCHAR(80) NOT NULL;

-- 3. usunięcie kolumny wraz z zawartymi w niej danymi
ALTER TABLE uczniowie DROP COLUMN telefon;

-- 4. dodanie ograniczenia do istniejącej tabeli
ALTER TABLE przedmioty ADD CONSTRAINT uq_nazwa UNIQUE (nazwa);

-- 5. zmiana nazwy tabeli
ALTER TABLE przedmioty RENAME TO przedmioty_szkolne;

DROP TABLE oceny;              -- tabela oceny przestaje istnieć
DROP DATABASE szkola;          -- znika cała baza wraz z tabelami
TRUNCATE TABLE oceny;          -- tabela zostaje, ale jest pusta, licznik id od 1
DELETE FROM oceny WHERE ocena = 1;   -- usuwa tylko jedynki

-- bezpieczne warianty, gdy nie wiadomo, czy obiekt istnieje
DROP TABLE IF EXISTS oceny;
CREATE TABLE IF NOT EXISTS przedmioty (
id_przedmiotu INT AUTO_INCREMENT PRIMARY KEY,
nazwa VARCHAR(50) NOT NULL
);

-- jeden rekord, wskazane kolumny (zalecany zapis)
INSERT INTO klasy (nazwa, profil, wychowawca)
VALUES ('3A', 'programista', 'Anna Kowalska');

-- wiele rekordów jednym poleceniem: kolejne nawiasy po przecinku
INSERT INTO klasy (nazwa, profil, wychowawca) VALUES
('3B', 'grafik',       'Piotr Nowak'),
('4A', 'programista',  'Ewa Zielinska'),
('4B', 'sieciowiec',   'Marek Lis');

-- wstawienie ucznia; id_ucznia nadaje AUTO_INCREMENT, więc go nie podajemy
INSERT INTO uczniowie (imie, nazwisko, data_urodzenia, email, id_klasy)
VALUES ('Jan', 'Kowalczyk', '2008-04-12', 'jan.k@zsp.edu.pl', 1);

-- wersja bez listy kolumn: MUSISZ podać wartości dla wszystkich kolumn
-- w kolejności z definicji tabeli, łącznie z NULL dla id
INSERT INTO przedmioty VALUES (NULL, 'Bazy danych', 4);

-- przeniesienie jednego ucznia do klasy o id 3
UPDATE uczniowie
SET id_klasy = 3
WHERE id_ucznia = 7;

-- zmiana dwóch kolumn naraz
UPDATE przedmioty
SET nazwa = 'Systemy baz danych', liczba_godzin = 5
WHERE id_przedmiotu = 2;

-- podniesienie wagi wszystkim ocenom z przedmiotu 4 o 1
UPDATE oceny
SET waga = waga + 1
WHERE id_przedmiotu = 4;

-- KATASTROFA: brak WHERE ustawia ocenę 5 KAŻDEMU uczniowi z KAŻDEGO przedmiotu
UPDATE oceny SET ocena = 5;

-- usunięcie jednego ucznia
DELETE FROM uczniowie WHERE id_ucznia = 12;

-- usunięcie wszystkich ocen niedostatecznych wpisanych przed 1 września
DELETE FROM oceny
WHERE ocena = 1 AND data_wpisu < '2026-09-01';

-- usunięcie ocen ucznia, którego zaraz skreślamy z listy
-- (najpierw potomna tabela oceny, potem uczniowie - inaczej klucz obcy zablokuje)
DELETE FROM oceny     WHERE id_ucznia = 12;
DELETE FROM uczniowie WHERE id_ucznia = 12;

-- wszystkie kolumny wszystkich uczniów
SELECT * FROM uczniowie;

-- tylko wybrane kolumny
SELECT imie, nazwisko, email FROM uczniowie;

-- DISTINCT usuwa duplikaty z wyniku:
-- zamiast czterech wierszy 'programista' dostaniesz jeden
SELECT DISTINCT profil FROM klasy;

-- DISTINCT działa na całym zestawie kolumn, nie na pierwszej z nich
SELECT DISTINCT profil, wychowawca FROM klasy;

-- uczniowie klasy o id 2
SELECT imie, nazwisko FROM uczniowie WHERE id_klasy = 2;

-- wszystkie oceny inne niż dopuszczająca
SELECT * FROM oceny WHERE ocena <> 2;

-- oceny z przedziału 4-5 WŁĄCZNIE z krańcami
SELECT id_ucznia, ocena FROM oceny WHERE ocena BETWEEN 4 AND 5;

-- to samo zapisane porównaniami - dokładnie ten sam wynik
SELECT id_ucznia, ocena FROM oceny WHERE ocena >= 4 AND ocena <= 5;

-- uczniowie z trzech wskazanych klas
SELECT nazwisko FROM uczniowie WHERE id_klasy IN (1, 3, 5);

-- nazwiska na -ski oraz imiona trzyliterowe zaczynające się na A
SELECT nazwisko FROM uczniowie WHERE nazwisko LIKE '%ski';
SELECT imie     FROM uczniowie WHERE imie LIKE 'A_a';

-- uczniowie bez przypisanej klasy - NULL sprawdzamy TYLKO przez IS NULL
SELECT imie, nazwisko FROM uczniowie WHERE id_klasy IS NULL;
SELECT imie, nazwisko FROM uczniowie WHERE email IS NOT NULL;

-- ZŁE ROZUMIENIE: to zapytanie zwróci uczniów z klasy 1
-- ORAZ wszystkich uczniów z klasy 2 mających e-mail
SELECT * FROM uczniowie
WHERE id_klasy = 1 OR id_klasy = 2 AND email IS NOT NULL;

-- czyli serwer czyta to tak:
SELECT * FROM uczniowie
WHERE id_klasy = 1 OR (id_klasy = 2 AND email IS NOT NULL);

-- ZAMIERZONE: uczniowie z klasy 1 lub 2, którzy mają e-mail
SELECT * FROM uczniowie
WHERE (id_klasy = 1 OR id_klasy = 2) AND email IS NOT NULL;

-- NOT zaprzecza warunkowi bezpośrednio po nim
SELECT * FROM uczniowie WHERE NOT id_klasy = 3;
SELECT * FROM oceny     WHERE ocena NOT BETWEEN 2 AND 3;
SELECT * FROM klasy     WHERE profil NOT IN ('grafik', 'sieciowiec');

-- sortowanie rosnąco; ASC jest domyślne, więc można je pominąć
SELECT nazwisko, imie FROM uczniowie ORDER BY nazwisko ASC;

-- malejąco po ocenie
SELECT id_ucznia, ocena FROM oceny ORDER BY ocena DESC;

-- po wielu kolumnach: najpierw klasa rosnąco, w ramach klasy nazwisko rosnąco
SELECT id_klasy, nazwisko, imie
FROM uczniowie
ORDER BY id_klasy ASC, nazwisko ASC;

-- każda kolumna ma własny kierunek
SELECT id_klasy, nazwisko FROM uczniowie ORDER BY id_klasy DESC, nazwisko ASC;

-- LIMIT: pięć najwyższych ocen
SELECT id_ucznia, ocena FROM oceny ORDER BY ocena DESC LIMIT 5;

-- LIMIT z przesunięciem: pomiń 10 wierszy, weź kolejne 5 (strona 3 listy)
SELECT nazwisko FROM uczniowie ORDER BY nazwisko LIMIT 10, 5;
SELECT nazwisko FROM uczniowie ORDER BY nazwisko LIMIT 5 OFFSET 10;

-- alias kolumny: nagłówek w wyniku brzmi 'Nazwisko ucznia'
SELECT nazwisko AS 'Nazwisko ucznia', imie AS Imie FROM uczniowie;

-- alias tabeli skraca zapis przy złączeniach
SELECT u.nazwisko, k.nazwa
FROM uczniowie AS u, klasy AS k
WHERE u.id_klasy = k.id_klasy;

-- kolumna obliczeniowa: łączenie tekstu i wyliczenie liczbowe
SELECT CONCAT(imie, ' ', nazwisko) AS pelne_imie FROM uczniowie;

SELECT nazwa, liczba_godzin, liczba_godzin * 30 AS godzin_w_roku
FROM przedmioty;

-- ocena ważona jako kolumna wyliczana
SELECT id_ucznia, ocena, waga, ocena * waga AS punkty FROM oceny;

-- funkcje na tekście i dacie, które warto znać
SELECT UPPER(nazwisko) AS wielkimi,
     LOWER(imie)     AS malymi,
     LENGTH(nazwisko) AS dlugosc,
     YEAR(data_urodzenia) AS rocznik
FROM uczniowie;

-- INNER JOIN: uczeń wraz z nazwą swojej klasy.
-- Uczeń z id_klasy = NULL NIE pojawi się w wyniku.
SELECT u.imie, u.nazwisko, k.nazwa AS klasa, k.profil
FROM uczniowie AS u
INNER JOIN klasy AS k ON u.id_klasy = k.id_klasy
ORDER BY k.nazwa, u.nazwisko;

-- ten sam efekt zapisany warunkiem w WHERE (starsza składnia)
SELECT u.imie, u.nazwisko, k.nazwa
FROM uczniowie u, klasy k
WHERE u.id_klasy = k.id_klasy;

SELECT u.nazwisko, p.nazwa AS przedmiot, o.ocena
FROM uczniowie AS u
LEFT JOIN oceny AS o      ON u.id_ucznia = o.id_ucznia
LEFT JOIN przedmioty AS p ON o.id_przedmiotu = p.id_przedmiotu
ORDER BY u.nazwisko;

-- Możliwy wynik:
-- nazwisko    | przedmiot     | ocena
-- ------------+---------------+-------
-- Baran       | Bazy danych   | 4.0
-- Baran       | Sieci         | 3.0
-- Kowalczyk   | Bazy danych   | 5.0
-- Wilk        | NULL          | NULL     <-- uczennica bez ani jednej oceny
--
-- Przy INNER JOIN wiersz z Wilk w ogóle by nie powstał.

-- klasyczne zadanie: wypisz uczniów, którzy NIE MAJĄ żadnej oceny.
-- LEFT JOIN + warunek na NULL po stronie prawej tabeli
SELECT u.imie, u.nazwisko
FROM uczniowie AS u
LEFT JOIN oceny AS o ON u.id_ucznia = o.id_ucznia
WHERE o.id_oceny IS NULL;

-- RIGHT JOIN: wszystkie klasy, także te, do których nikt nie chodzi.
-- Tabela klasy stoi po prawej stronie słowa JOIN, więc to ona jest zachowana.
SELECT u.nazwisko, k.nazwa AS klasa
FROM uczniowie AS u
RIGHT JOIN klasy AS k ON u.id_klasy = k.id_klasy;

-- to samo, ale zapisane jako LEFT JOIN po zamianie tabel miejscami
SELECT u.nazwisko, k.nazwa AS klasa
FROM klasy AS k
LEFT JOIN uczniowie AS u ON u.id_klasy = k.id_klasy;

-- pełna informacja: kto, z jakiej klasy, z jakiego przedmiotu, jaka ocena
SELECT k.nazwa       AS klasa,
     u.nazwisko    AS uczen,
     p.nazwa       AS przedmiot,
     o.ocena,
     o.data_wpisu
FROM oceny AS o
INNER JOIN uczniowie  AS u ON o.id_ucznia     = u.id_ucznia
INNER JOIN przedmioty AS p ON o.id_przedmiotu = p.id_przedmiotu
INNER JOIN klasy      AS k ON u.id_klasy      = k.id_klasy
WHERE o.ocena >= 5
ORDER BY k.nazwa, u.nazwisko;

-- Zwraca wszystkie oceny bardzo dobre i celujące wraz z nazwiskiem ucznia,
-- nazwą jego klasy i nazwą przedmiotu, uporządkowane klasami.

-- ilu jest uczniów w całej szkole
SELECT COUNT(*) AS liczba_uczniow FROM uczniowie;

-- ilu uczniów ma podany adres e-mail (NULL nie jest liczony)
SELECT COUNT(email) AS z_mailem FROM uczniowie;

-- średnia, najniższa i najwyższa ocena w całej bazie
SELECT AVG(ocena) AS srednia,
     MIN(ocena) AS najnizsza,
     MAX(ocena) AS najwyzsza,
     COUNT(*)   AS ile_ocen
FROM oceny;

-- średnia zaokrąglona do dwóch miejsc po przecinku
SELECT ROUND(AVG(ocena), 2) AS srednia FROM oceny;

-- suma godzin wszystkich przedmiotów
SELECT SUM(liczba_godzin) AS godzin_lacznie FROM przedmioty;

-- liczba uczniów w każdej klasie
SELECT k.nazwa AS klasa, COUNT(u.id_ucznia) AS liczba_uczniow
FROM klasy AS k
LEFT JOIN uczniowie AS u ON k.id_klasy = u.id_klasy
GROUP BY k.nazwa
ORDER BY liczba_uczniow DESC;

-- Dzięki LEFT JOIN klasa bez uczniów pojawi się z wynikiem 0.
-- Gdyby użyć COUNT(*), taka klasa pokazałaby błędnie 1.

-- średnia ocena każdego ucznia
SELECT u.nazwisko, u.imie, ROUND(AVG(o.ocena), 2) AS srednia
FROM uczniowie AS u
INNER JOIN oceny AS o ON u.id_ucznia = o.id_ucznia
GROUP BY u.id_ucznia, u.nazwisko, u.imie
ORDER BY srednia DESC;

-- średnia z każdego przedmiotu w każdej klasie (grupowanie po dwóch kolumnach)
SELECT k.nazwa AS klasa, p.nazwa AS przedmiot, ROUND(AVG(o.ocena), 2) AS srednia
FROM oceny AS o
INNER JOIN uczniowie  AS u ON o.id_ucznia = u.id_ucznia
INNER JOIN klasy      AS k ON u.id_klasy = k.id_klasy
INNER JOIN przedmioty AS p ON o.id_przedmiotu = p.id_przedmiotu
GROUP BY k.nazwa, p.nazwa
ORDER BY k.nazwa, p.nazwa;

-- klasy, w których uczy się więcej niż 25 uczniów
SELECT k.nazwa, COUNT(u.id_ucznia) AS ilu
FROM klasy AS k
INNER JOIN uczniowie AS u ON k.id_klasy = u.id_klasy
GROUP BY k.nazwa
HAVING COUNT(u.id_ucznia) > 25;

-- uczniowie ze średnią powyżej 4.5, liczoną TYLKO z ocen wpisanych w 2026 r.
SELECT u.nazwisko, ROUND(AVG(o.ocena), 2) AS srednia
FROM uczniowie AS u
INNER JOIN oceny AS o ON u.id_ucznia = o.id_ucznia
WHERE YEAR(o.data_wpisu) = 2026        -- filtr wierszy PRZED grupowaniem
GROUP BY u.id_ucznia, u.nazwisko
HAVING AVG(o.ocena) > 4.5              -- filtr grup PO grupowaniu
ORDER BY srednia DESC;

-- BŁĄD: agregat w WHERE. Serwer odrzuci to zapytanie.
SELECT u.nazwisko FROM uczniowie u
JOIN oceny o ON u.id_ucznia = o.id_ucznia
WHERE AVG(o.ocena) > 4.5
GROUP BY u.nazwisko;

-- przedmioty, z których wystawiono co najmniej 10 ocen
SELECT p.nazwa, COUNT(*) AS ile_ocen
FROM przedmioty AS p
INNER JOIN oceny AS o ON p.id_przedmiotu = o.id_przedmiotu
GROUP BY p.nazwa
HAVING COUNT(*) >= 10
ORDER BY ile_ocen DESC;

-- podzapytanie zwracające JEDNĄ wartość - porównanie operatorem
SELECT id_ucznia, ocena
FROM oceny
WHERE ocena > (SELECT AVG(ocena) FROM oceny);
-- Zwraca oceny wyższe od średniej wszystkich ocen w bazie.

-- podzapytanie zwracające LISTĘ wartości - operator IN
SELECT imie, nazwisko
FROM uczniowie
WHERE id_klasy IN (SELECT id_klasy FROM klasy WHERE profil = 'programista');
-- Zwraca uczniów wszystkich klas o profilu programista.

-- podzapytanie skorelowane - odwołuje się do zapytania zewnętrznego
SELECT u.nazwisko
FROM uczniowie AS u
WHERE NOT EXISTS (
SELECT 1 FROM oceny AS o WHERE o.id_ucznia = u.id_ucznia
);
-- Uczniowie bez ani jednej oceny - alternatywa dla LEFT JOIN ... IS NULL.

-- podzapytanie w SELECT jako kolumna wyliczana
SELECT u.nazwisko,
     (SELECT COUNT(*) FROM oceny AS o WHERE o.id_ucznia = u.id_ucznia) AS ile_ocen
FROM uczniowie AS u
ORDER BY ile_ocen DESC;

-- uczeń z najwyższą oceną
SELECT id_ucznia, ocena FROM oceny
WHERE ocena = (SELECT MAX(ocena) FROM oceny);

-- BŁĄD: alias godzin_w_roku nie istnieje jeszcze na etapie WHERE
SELECT nazwa, liczba_godzin * 30 AS godzin_w_roku
FROM przedmioty
WHERE godzin_w_roku > 100;

-- POPRAWNIE: w WHERE powtarzamy wyrażenie
SELECT nazwa, liczba_godzin * 30 AS godzin_w_roku
FROM przedmioty
WHERE liczba_godzin * 30 > 100
ORDER BY godzin_w_roku DESC;      -- tu alias działa, bo ORDER BY jest po SELECT

-- LIMIT bez ORDER BY: dostaniesz 5 wierszy, ale nikt nie gwarantuje KTÓRYCH
SELECT nazwisko FROM uczniowie LIMIT 5;

-- LIMIT z ORDER BY: pięciu uczniów alfabetycznie od końca - wynik powtarzalny
SELECT nazwisko FROM uczniowie ORDER BY nazwisko DESC LIMIT 5;

SELECT k.nazwa AS klasa, ROUND(AVG(o.ocena), 2) AS srednia
FROM oceny AS o
INNER JOIN uczniowie AS u ON o.id_ucznia = u.id_ucznia
INNER JOIN klasy AS k     ON u.id_klasy = k.id_klasy
WHERE o.ocena > 1
GROUP BY k.nazwa
HAVING AVG(o.ocena) > 4
ORDER BY srednia DESC
LIMIT 3;

-- utworzenie konta logującego się tylko z tego samego komputera
CREATE USER 'nauczyciel'@'localhost' IDENTIFIED BY 'Tajne_haslo1';

-- konto dostępne z dowolnego hosta w sieci
CREATE USER 'sekretariat'@'%' IDENTIFIED BY 'Inne_haslo2';

-- odczyt całej bazy szkola
GRANT SELECT ON szkola.* TO 'nauczyciel'@'localhost';

-- odczyt i modyfikacja danych, ale bez prawa zmiany struktury
GRANT SELECT, INSERT, UPDATE, DELETE ON szkola.* TO 'sekretariat'@'%';

-- uprawnienie zawężone do jednej tabeli
GRANT SELECT, INSERT ON szkola.oceny TO 'nauczyciel'@'localhost';

-- uprawnienie zawężone do wskazanych kolumn jednej tabeli
GRANT SELECT (imie, nazwisko) ON szkola.uczniowie TO 'nauczyciel'@'localhost';

-- pełnia praw do jednej bazy, z możliwością przekazywania ich dalej
GRANT ALL PRIVILEGES ON szkola.* TO 'admin_szkoly'@'localhost' WITH GRANT OPTION;

-- zastosowanie zmian i podgląd nadanych uprawnień
FLUSH PRIVILEGES;
SHOW GRANTS FOR 'nauczyciel'@'localhost';

-- odebranie pojedynczego uprawnienia
REVOKE DELETE ON szkola.* FROM 'sekretariat'@'%';

-- odebranie wszystkiego
REVOKE ALL PRIVILEGES, GRANT OPTION FROM 'sekretariat'@'%';

-- zmiana hasła i usunięcie konta
ALTER USER 'nauczyciel'@'localhost' IDENTIFIED BY 'Nowe_haslo3';
DROP USER 'nauczyciel'@'localhost';