Ćwiczenia z kwerend SQL

CREATE · SELECT · JOIN · GROUP BY · HAVING · SUBQUERY

Przećwicz kwerendy na bazie sklepu internetowego – od prostych SELECT po złożone zapytania
Poziom 1Tworzenie tabel
CREATE DATABASE · CREATE TABLE · INSERT

1Tworzenie tabeli produktów

Cel: Utworzenie bazy danych i tabeli Produkty oraz dodanie przykładowych danych.

Polecenie: Stwórz bazę SklepInternetowy, tabelę Produkty i wstaw kilka rekordów, a następnie sprawdź strukturę tabeli poleceniem DESCRIBE.

SQL · DDL + INSERT 
CREATE DATABASE SklepInternetowy;

USE SklepInternetowy;

CREATE TABLE Produkty (
  ID_Produktu     INT PRIMARY KEY,
  Nazwa_Produktu  VARCHAR(100),
  Cena            DECIMAL(10, 2),
  Kategoria       VARCHAR(50)
);

INSERT INTO Produkty (ID_Produktu, Nazwa_Produktu, Cena, Kategoria)
VALUES 
  (1, 'Laptop',     2999.99, 'Elektronika'),
  (2, 'Smartphone',  999.99, 'Telefony');

DESCRIBE Produkty;

✏️ Twoje notatki (dodatkowe kolumny, typy, klucze):

Poziom 1Łączenie danych
JOIN · relacja Zamówienia–Produkty

2Dołączanie danych z tabeli produktów

Cel: Ćwiczenie zapytań łączących tabelę zamówień z tabelą produktów.

Polecenie: Utwórz tabelę Zamówienia, a następnie napisz zapytanie, które pokaże nazwę produktu, cenę i ilość w każdym zamówieniu.

SQL · JOIN 
CREATE TABLE Zamówienia (
  ID_Zamówienia INT PRIMARY KEY,
  ID_Produktu   INT,
  Ilość         INT
);

SELECT 
  p.Nazwa_Produktu,
  p.Cena,
  z.Ilość
FROM Zamówienia z
INNER JOIN Produkty p
  ON z.ID_Produktu = p.ID_Produktu;

✏️ Rozszerz zapytanie (wartość pozycji, aliasy, sortowanie):

Poziom 1Usuwanie danych
DELETE · warunki w WHERE

3Usuwanie klientów bez e‑maila

Cel: Nauka usuwania danych na podstawie warunków logicznych.

Polecenie: Utwórz tabelę Klienci, dodaj przykładowe rekordy, a następnie usuń klientów bez adresu e‑mail oraz klientów o wybranym nazwisku.

SQL · DELETE 
CREATE TABLE Klienci (
  ID_Klienta INT PRIMARY KEY,
  Imię       VARCHAR(50),
  Nazwisko   VARCHAR(50),
  Email      VARCHAR(100)
);

/* przykładowe usuwanie */
DELETE FROM Klienci
WHERE Email IS NULL;

DELETE FROM Klienci
WHERE Nazwisko = 'Nowak';

✏️ Dopisz przykłady z innymi warunkami (LIKE, IN, BETWEEN):

Poziom 2Grupowanie i agregacje
GROUP BY · AVG · SUM

4Średnia ocena produktów

Cel: Ćwiczenie funkcji agregujących i grupowania wyników.

Polecenie: Utwórz tabelę Opinie i oblicz średnią ocenę dla każdego produktu.

SQL · GROUP BY 
CREATE TABLE Opinie (
  ID_Opinie    INT PRIMARY KEY,
  ID_Produktu  INT,
  Ocena        INT,
  Data_Opinie  DATE
);

SELECT 
  ID_Produktu,
  AVG(Ocena) AS Średnia_Ocena
FROM Opinie
GROUP BY ID_Produktu;

✏️ Dodaj warunki (HAVING, filtr po dacie, minimalna liczba opinii):

Poziom 3Podzapytania
SUBQUERY · AVG · filtr w WHERE

5Produkty droższe niż średnia

Cel: Zastosowanie podzapytania w klauzuli WHERE.

Polecenie: Wyświetl produkty, których cena jest wyższa niż średnia cena wszystkich produktów.

SQL · SUBQUERY 
SELECT 
  Nazwa_Produktu,
  Cena
FROM Produkty
WHERE Cena > (
  SELECT AVG(Cena)
  FROM Produkty
);

✏️ Wymyśl inne podzapytanie (np. klienci powyżej średniej liczby zamówień):

Poziom 2Warunki i filtrowanie
WHERE · LIKE · filtr po mieście

6Kwerendy z warunkami

Cel: Tworzenie zapytań filtrujących klientów według miasta i wzorca nazwiska.

Polecenie: Utwórz tabelę Klienci, wprowadź dane, a następnie napisz zapytania wybierające klientów z wybranego miasta oraz z nazwiskiem zaczynającym się na daną literę.

SQL · WHERE · LIKE 
CREATE TABLE Klienci (
  ID_Klienta INT PRIMARY KEY,
  Imię       VARCHAR(50),
  Nazwisko   VARCHAR(50),
  Email      VARCHAR(100),
  Miasto     VARCHAR(50)
);

SELECT *
FROM Klienci
WHERE Miasto = 'Warszawa';

SELECT *
FROM Klienci
WHERE Nazwisko LIKE 'K%';

✏️ Dodaj własne warunki (AND, OR, BETWEEN, IN):

Poziom 2Funkcje w zapytaniach
ROUND · CONCAT · formatowanie wyników

7Kwerendy z użyciem funkcji

Cel: Wykorzystanie funkcji wbudowanych (np. ROUND, CONCAT) podczas pracy na tabeli produktów.

Polecenie: Utwórz tabelę Produkty, dodaj kilka rekordów, a następnie użyj funkcji do zaokrąglania cen i budowania opisów produktów.

SQL · funkcje 
CREATE TABLE Produkty (
  ID_Produktu     INT PRIMARY KEY,
  Nazwa_Produktu  VARCHAR(100),
  Cena            DECIMAL(10, 2)
);

SELECT 
  Nazwa_Produktu,
  ROUND(Cena, 2) AS Cena_zaokrąglona
FROM Produkty;

SELECT 
  CONCAT(Nazwa_Produktu, ' - ', Cena) AS Produkt_Cena
FROM Produkty;

✏️ Dodaj inne funkcje (LOWER, UPPER, LENGTH, NOW):

Poziom 3Podzapytania
SUBQUERY · AVG · filtrowanie po średniej

8Kwerendy z użyciem podzapytań

Cel: Ćwiczenie podzapytań w klauzuli WHERE na przykładzie tabeli Sprzedawcy.

Polecenie: Utwórz tabelę Sprzedawcy, dodaj dane, a następnie wyświetl tych sprzedawców, którzy zarabiają więcej niż średnia pensja wszystkich sprzedawców.

SQL · SUBQUERY 
CREATE TABLE Sprzedawcy (
  ID_Sprzedawcy  INT PRIMARY KEY,
  Imię           VARCHAR(50),
  Nazwisko       VARCHAR(50),
  Wynagrodzenie  DECIMAL(10, 2)
);

SELECT 
  Imię,
  Nazwisko
FROM Sprzedawcy
WHERE Wynagrodzenie > (
  SELECT AVG(Wynagrodzenie)
  FROM Sprzedawcy
);

✏️ Wymyśl inne podzapytanie (np. powyżej średniej sprzedaży, powyżej mediany):

Poziom 1Sortowanie danych
ORDER BY · ASC · DESC

9Kwerendy z sortowaniem

Cel: Ćwiczenie sortowania wyników zapytań według daty i wartości zamówienia.

Polecenie: Utwórz tabelę Zamówienia, dodaj dane, a następnie posortuj rekordy po dacie oraz po wartości zamówienia.

SQL · ORDER BY 
CREATE TABLE Zamówienia (
  ID_Zamówienia   INT PRIMARY KEY,
  Data_Zamówienia DATE,
  Wartość         DECIMAL(10, 2)
);

SELECT *
FROM Zamówienia
ORDER BY Data_Zamówienia ASC;

SELECT *
FROM Zamówienia
ORDER BY Wartość DESC;

✏️ Dodaj kolejne sortowania (po kilku kolumnach, mieszane ASC/DESC):

Poziom 2Łączenie tabel
JOIN · wartość zamówienia

10Kwerendy z użyciem JOIN – wartość zamówień

Cel: Połączenie tabel Produkty i Zamówienia oraz obliczenie wartości zamówienia.

Polecenie: Utwórz tabele Produkty i Zamówienia, wypełnij je danymi, a następnie wyświetl nazwę produktu, datę zamówienia i łączną wartość (Cena * Ilość).

SQL · JOIN · wyliczenia 
CREATE TABLE Produkty (
  ID_Produktu     INT PRIMARY KEY,
  Nazwa_Produktu  VARCHAR(100),
  Cena            DECIMAL(10, 2)
);

CREATE TABLE Zamówienia (
  ID_Zamówienia   INT PRIMARY KEY,
  ID_Produktu     INT,
  Data_Zamówienia DATE,
  Ilość           INT,
  FOREIGN KEY (ID_Produktu) REFERENCES Produkty(ID_Produktu)
);

SELECT 
  p.Nazwa_Produktu,
  z.Data_Zamówienia,
  (p.Cena * z.Ilość) AS Wartość_Zamówienia
FROM Produkty p
JOIN Zamówienia z
  ON p.ID_Produktu = z.ID_Produktu;

✏️ Rozbuduj zapytanie (aliasy, zaokrąglanie, warunki po dacie/cenie):

Poziom 2Łączenie wyników
UNION · scalanie list

11Kwerendy z użyciem UNION

Cel: Połączenie nazwisk pracowników pochodzących z dwóch różnych tabel.

Polecenie: Utwórz tabele Sprzedawcy i Pracownicy, a następnie połącz nazwiska z obu tabel jednym zapytaniem za pomocą UNION.

SQL · UNION 
CREATE TABLE Sprzedawcy (
  ID_Sprzedawcy  INT PRIMARY KEY,
  Imię           VARCHAR(50),
  Nazwisko       VARCHAR(50),
  Wynagrodzenie  DECIMAL(10, 2)
);

CREATE TABLE Pracownicy (
  ID_Pracownika  INT PRIMARY KEY,
  Imię           VARCHAR(50),
  Nazwisko       VARCHAR(50),
  Stanowisko     VARCHAR(50)
);

SELECT Nazwisko
FROM Sprzedawcy
UNION
SELECT Nazwisko
FROM Pracownicy;

✏️ Zmień UNION na UNION ALL, dodaj filtry, posortuj wynik:

Poziom 3Grupowanie z warunkiem
GROUP BY · HAVING · suma

12GROUP BY i HAVING – klienci z dużą sprzedażą

Cel: Analiza łącznej wartości zamówień klientów z użyciem GROUP BY i HAVING.

Polecenie: Utwórz tabelę Zamówienia, wypełnij danymi, a następnie znajdź klientów, których łączna wartość zamówień przekracza określony próg (np. 1000) i posortuj wynik malejąco.

SQL · GROUP BY + HAVING 
CREATE TABLE Zamówienia (
  ID_Zamówienia   INT PRIMARY KEY,
  ID_Klienta      INT,
  Wartość         DECIMAL(10, 2),
  Data_Zamówienia DATE
);

SELECT 
  ID_Klienta,
  SUM(Wartość) AS Łączna_Wartość
FROM Zamówienia
GROUP BY ID_Klienta
HAVING SUM(Wartość) > 1000
ORDER BY Łączna_Wartość DESC;

✏️ Zmień próg HAVING, dodaj filtr po dacie, połącz z tabelą Klienci:

Poziom 1Usuwanie duplikatów
DISTINCT · unikalne wartości

13Kwerendy z użyciem DISTINCT

Cel: Wyświetlanie unikalnych wartości (np. kwot transakcji) bez duplikatów.

Polecenie: Utwórz tabelę Transakcje, dodaj dane, a następnie wypisz tylko unikalne kwoty transakcji przy użyciu DISTINCT.

SQL · DISTINCT 
CREATE TABLE Transakcje (
  ID_Transakcji   INT PRIMARY KEY,
  ID_Klienta      INT,
  Kwota           DECIMAL(10, 2),
  Data_Transakcji DATE
);

SELECT DISTINCT Kwota
FROM Transakcje;

✏️ Spróbuj DISTINCT na innych kolumnach (miasto, kategoria):

Poziom 2CASE – logika warunkowa
CASE · klasyfikacja sprzedawców

14Kwerenda z użyciem CASE

Cel: Klasyfikacja sprzedawców w oparciu o wysokość sprzedaży przy użyciu wyrażenia CASE.

Polecenie: Utwórz tabelę Sprzedawcy, dodaj dane, a następnie przypisz każdemu sprzedawcy kategorię: „Top Seller”, „Average Seller” lub „Low Seller”.

SQL · CASE 
CREATE TABLE Sprzedawcy (
  ID_Sprzedawcy  INT PRIMARY KEY,
  Imię           VARCHAR(50),
  Sprzedaż       DECIMAL(10, 2),
  Region         VARCHAR(50)
);

SELECT 
  Imię,
  CASE
    WHEN Sprzedaż > 5000 THEN 'Top Seller'
    WHEN Sprzedaż BETWEEN 2000 AND 5000 THEN 'Average Seller'
    ELSE 'Low Seller'
  END AS Klasyfikacja
FROM Sprzedawcy;

✏️ Zmień progi, dodaj więcej poziomów lub uwzględnij region:

Poziom 3Subqueries – porównanie do średniej
SUBQUERY · AVG · produkty powyżej średniej

15Kwerendy z użyciem subqueries

Cel: Znalezienie produktów droższych niż średnia cena wszystkich produktów.

Polecenie: Utwórz tabele Produkty i Zamówienia, dodaj dane, a następnie wypisz tylko te produkty, których cena jest wyższa niż średnia cena z tabeli Produkty.

SQL · SUBQUERY · AVG 
CREATE TABLE Produkty (
  ID_Produktu INT PRIMARY KEY,
  Nazwa       VARCHAR(100),
  Cena        DECIMAL(10, 2)
);

CREATE TABLE Zamówienia (
  ID_Zamówienia INT PRIMARY KEY,
  ID_Produktu   INT,
  Ilość         INT
);

SELECT 
  Nazwa,
  Cena
FROM Produkty
WHERE Cena > (
  SELECT AVG(Cena)
  FROM Produkty
);

✏️ Wymyśl inne subquery (np. produkty częściej zamawiane niż średnia ilość):

Poziom 2Zmiany struktury tabel
ALTER TABLE · dodawanie kolumn

16Kwerendy z użyciem ALTER TABLE

Cel: Modyfikacja struktury tabeli studentów (dodawanie i zmiana kolumn).

Polecenie: Utwórz tabelę Studenci, dodaj dane, a następnie dodaj kolumnę Email i pozwól na wartości NULL w tej kolumnie.

SQL · ALTER TABLE 
CREATE TABLE Studenci (
  ID_Studenta   INT PRIMARY KEY,
  Imię          VARCHAR(50),
  Nazwisko      VARCHAR(50),
  Rok_Urodzenia YEAR
);

ALTER TABLE Studenci
ADD COLUMN Email VARCHAR(100);

ALTER TABLE Studenci
MODIFY COLUMN Email VARCHAR(100) NULL;

✏️ Dodaj inne modyfikacje (DROP COLUMN, zmiana typu, dodanie CONSTRAINT):

Poziom 1Czyszczenie tabel
TRUNCATE · opróżnianie danych

17Kwerendy z użyciem TRUNCATE

Cel: Opróżnianie zawartości tabeli magazynowej bez usuwania jej struktury.

Polecenie: Utwórz tabelę Magazyn, dodaj dane, a następnie wyczyść ją za pomocą polecenia TRUNCATE TABLE. Porównaj działanie z DELETE.

SQL · TRUNCATE 
CREATE TABLE Magazyn (
  ID_Produktu INT PRIMARY KEY,
  Nazwa       VARCHAR(100),
  Ilość       INT,
  Cena        DECIMAL(10, 2)
);

TRUNCATE TABLE Magazyn;

✏️ Zanotuj różnicę TRUNCATE vs DELETE (logi, reset AUTO_INCREMENT, FK):

Poziom 1Usuwanie z warunkiem
DELETE · WHERE · miasto

18Kwerendy z użyciem DELETE

Cel: Usuwanie rekordów klientów na podstawie warunku (miasto).

Polecenie: Utwórz tabelę Klienci, dodaj dane, a następnie usuń wszystkich klientów z wybranego miasta (np. „Warszawa”).

SQL · DELETE · WHERE 
CREATE TABLE Klienci (
  ID_Klienta INT PRIMARY KEY,
  Imię       VARCHAR(50),
  Nazwisko   VARCHAR(50),
  Adres      VARCHAR(100),
  Miasto     VARCHAR(50)
);

DELETE FROM Klienci
WHERE Miasto = 'Warszawa';

✏️ Dodaj inne warunki (kilka miast, zakres ID, AND/OR):

Poziom 1Lista wartości
IN · porównanie do zestawu

19Kwerendy z użyciem IN

Cel: Filtrowanie rekordów na podstawie listy dopuszczalnych wartości ceny.

Polecenie: Utwórz tabelę Produkty, dodaj dane, a następnie wyświetl tylko te produkty, których cena należy do zbioru (100, 200, 300) przy użyciu operatora IN.

SQL · IN 
CREATE TABLE Produkty (
  ID_Produktu INT PRIMARY KEY,
  Nazwa       VARCHAR(100),
  Cena        DECIMAL(10, 2)
);

SELECT 
  Nazwa,
  Cena
FROM Produkty
WHERE Cena IN (100, 200, 300);

✏️ Zmień IN na NOT IN, użyj podzapytania zamiast listy stałej:

Poziom 2JOIN Klienci–Zamówienia
JOIN · relacja klient–zamówienie

20Kwerendy z użyciem JOIN – klienci i ich zamówienia

Cel: Połączenie tabel Klienci i Zamówienia w celu uzyskania raportu z nazwiskami klientów i datami ich zamówień.

Polecenie: Utwórz tabele Klienci i Zamówienia, dodaj dane, a następnie połącz je po ID_Klienta i wyświetl nazwisko klienta oraz datę zamówienia.

SQL · JOIN Klienci–Zamówienia 
CREATE TABLE Klienci (
  ID_Klienta INT PRIMARY KEY,
  Imię       VARCHAR(50),
  Nazwisko   VARCHAR(50)
);

CREATE TABLE Zamówienia (
  ID_Zamówienia INT PRIMARY KEY,
  ID_Klienta    INT,
  Data          DATE,
  Kwota         DECIMAL(10, 2)
);

SELECT 
  k.Nazwisko,
  z.Data
FROM Klienci k
INNER JOIN Zamówienia z
  ON k.ID_Klienta = z.ID_Klienta;

✏️ Dodaj kolumny (Imię, Kwota), filtr po dacie, ORDER BY:

Poziom 2UNION dwóch zbiorów klientów
UNION · miasta Warszawa/Kraków

21Kwerendy z użyciem UNION – klienci z dwóch tabel

Cel: Połączenie wyników z tabel Klienci_A i Klienci_B w jeden zbiór nazwisk.

Polecenie: Utwórz tabele Klienci_A i Klienci_B, dodaj dane, a następnie połącz nazwiska klientów z Warszawy i Krakowa przy użyciu UNION.

SQL · UNION – klienci 
CREATE TABLE Klienci_A (
  ID_Klienta INT PRIMARY KEY,
  Imię       VARCHAR(50),
  Nazwisko   VARCHAR(50),
  Miasto     VARCHAR(50)
);

CREATE TABLE Klienci_B (
  ID_Klienta INT PRIMARY KEY,
  Imię       VARCHAR(50),
  Nazwisko   VARCHAR(50),
  Miasto     VARCHAR(50)
);

SELECT Nazwisko
FROM Klienci_A
WHERE Miasto = 'Warszawa'
UNION
SELECT Nazwisko
FROM Klienci_B
WHERE Miasto = 'Kraków';

✏️ Dodaj UNION ALL, dociągnij imię, miasto, posortuj wynik:

Poziom 2Grupowanie wyników
GROUP BY · sumy per klient

22Kwerendy z użyciem GROUP BY

Cel: Grupowanie zamówień według klienta i obliczanie łącznej kwoty.

Polecenie: Utwórz tabelę Zamówienia, wprowadź dane, a następnie pogrupuj je po ID_Klienta, obliczając sumę kwot zamówień dla każdego klienta.

SQL · GROUP BY 
CREATE TABLE Zamówienia (
  ID_Zamówienia INT PRIMARY KEY,
  ID_Klienta    INT,
  Data          DATE,
  Kwota         DECIMAL(10, 2)
);

SELECT 
  ID_Klienta,
  SUM(Kwota) AS Suma_Zamówień
FROM Zamówienia
GROUP BY ID_Klienta;

✏️ Dodaj inne agregaty (AVG, COUNT), filtr po dacie:

Poziom 3HAVING po grupowaniu
GROUP BY · HAVING · próg wartości

23Kwerendy z użyciem HAVING

Cel: Filtrowanie grup po zsumowanej wartości zamówień.

Polecenie: Utwórz tabelę Zamówienia, dodaj dane, a następnie wyświetl tylko tych klientów, których suma zamówień przekroczyła 500, używając HAVING.

SQL · GROUP BY + HAVING 
CREATE TABLE Zamówienia (
  ID_Zamówienia INT PRIMARY KEY,
  ID_Klienta    INT,
  Data          DATE,
  Kwota         DECIMAL(10, 2)
);

SELECT 
  ID_Klienta,
  SUM(Kwota) AS Suma_Zamówień
FROM Zamówienia
GROUP BY ID_Klienta
HAVING SUM(Kwota) > 500;

✏️ Zmień próg, dodaj filtr po dacie w WHERE, posortuj wynik:

Poziom 1Sortowanie produktów
ORDER BY · cena malejąco

24Kwerendy z użyciem ORDER BY

Cel: Sortowanie listy produktów według ceny w kolejności malejącej.

Polecenie: Utwórz tabelę Produkty, dodaj dane, a następnie wyświetl produkty posortowane od najdroższego do najtańszego.

SQL · ORDER BY DESC 
CREATE TABLE Produkty (
  ID_Produktu INT PRIMARY KEY,
  Nazwa       VARCHAR(100),
  Cena        DECIMAL(10, 2)
);

SELECT 
  Nazwa,
  Cena
FROM Produkty
ORDER BY Cena DESC;

✏️ Zmień kierunek sortowania, dodaj drugi klucz (nazwa):

Poziom 2LIMIT – TOP N
LIMIT · TOP 5 najtańszych

25Kwerendy z użyciem LIMIT

Cel: Ograniczenie liczby wyników do kilku najtańszych produktów.

Polecenie: Utwórz tabelę Produkty, wprowadź dane, a następnie wyświetl 5 najtańszych produktów korzystając z ORDER BY oraz LIMIT.

SQL · LIMIT · TOP N 
CREATE TABLE Produkty (
  ID_Produktu INT PRIMARY KEY,
  Nazwa       VARCHAR(100),
  Cena        DECIMAL(10, 2)
);

SELECT 
  Nazwa,
  Cena
FROM Produkty
ORDER BY Cena ASC
LIMIT 5;

✏️ Zmień LIMIT, dodaj OFFSET, zrób TOP 10 najdroższych: