Ćwiczenia z Kwerend w Bazach Danych

Ćwiczenie 1: Kwerendy tworzące tabele

Cel: Tworzenie tabel za pomocą kwerend.

Zadanie:

  1. Stwórz bazę danych o nazwie SklepInternetowy.
  2. Utwórz tabelę Produkty za pomocą kwerendy tworzącej tabelę z następującymi kolumnami:
    • ID_Produktu (INT, Primary Key),
    • Nazwa_Produktu (VARCHAR(100)),
    • Cena (DECIMAL(10, 2)),
    • Kategoria (VARCHAR(50)).
  3. Sprawdź, czy tabela została utworzona poprawnie, wykonując zapytanie DESCRIBE Produkty.
  4. Wprowadź przykładowe dane do tabeli przy pomocy kwerendy INSERT INTO.

Przykładowy kod SQL:

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');

Ćwiczenie 2: Kwerendy dołączające dane

Cel: Dołączanie danych z innych tabel.

Zadanie:

  1. Utwórz tabelę Zamówienia z kolumnami:
    • ID_Zamówienia (INT, Primary Key),
    • ID_Produktu (INT),
    • Ilość (INT).
  2. Utwórz kwerendę, która dołączy dane z tabeli Produkty do tabeli Zamówienia, wyświetlając:
    • Nazwa_Produktu i Cena dla każdego zamówionego produktu.
  3. Sprawdź wynik zapytania i zoptymalizuj je, jeżeli to możliwe.

Przykładowy kod SQL:

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

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

Ćwiczenie 3: Kwerendy usuwające dane

Cel: Usuwanie danych z tabeli.

Zadanie:

  1. Stwórz tabelę Klienci z kolumnami:
    • ID_Klienta (INT, Primary Key),
    • Imię (VARCHAR(50)),
    • Nazwisko (VARCHAR(50)),
    • Email (VARCHAR(100)).
  2. Wprowadź przykładowe dane do tabeli Klienci.
  3. Napisz kwerendę usuwającą dane klientów, którzy nie mają przypisanego adresu email.
  4. Wykonaj kwerendę, aby usunąć dane klientów o określonym nazwisku (np. "Nowak").

Przykładowy kod SQL:

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

DELETE FROM Klienci WHERE Email IS NULL;

DELETE FROM Klienci WHERE Nazwisko = 'Nowak';

Ćwiczenie 4: Kwerendy krzyżowe

Cel: Tworzenie kwerend krzyżowych.

Zadanie:

  1. Utwórz tabelę Sprzedaż z kolumnami:
    • Data (DATE),
    • ID_Produktu (INT),
    • Ilość_Sprzedana (INT),
    • Przychód (DECIMAL(10, 2)).
  2. Utwórz kwerendę krzyżową, która wyświetli:
    • Zliczoną ilość sprzedanych produktów w poszczególnych miesiącach,
    • Porówna dane dla każdego produktu.
  3. Optymalizuj kwerendę, aby poprawić jej wydajność.

Przykładowy kod SQL:

CREATE TABLE Sprzedaż (
    Data DATE,
    ID_Produktu INT,
    Ilość_Sprzedana INT,
    Przychód DECIMAL(10, 2)
);

SELECT ID_Produktu, SUM(Ilość_Sprzedana) AS Ilość_Sprzedana,
    MONTH(Data) AS Miesiąc
FROM Sprzedaż
GROUP BY ID_Produktu, MONTH(Data)
PIVOT (SUM(Ilość_Sprzedana) FOR Miesiąc IN (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12));

Ćwiczenie 5: Kwerendy z grupowaniem danych

Cel: Grupowanie danych za pomocą kwerend.

Zadanie:

  1. Stwórz tabelę Opinie z kolumnami:
    • ID_Opinie (INT, Primary Key),
    • ID_Produktu (INT),
    • Ocena (INT),
    • Data_Opinie (DATE).
  2. Wprowadź dane do tabeli Opinie, przy czym każdemu produktowi przypisz oceny od 1 do 5.
  3. Utwórz kwerendę, która wyświetli średnią ocenę dla każdego produktu.
  4. Zoptymalizuj kwerendę, aby uzyskać wydajność przy dużych zbiorach danych.

Przykładowy kod SQL:

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;

Ćwiczenie 6: Kwerendy z warunkami

Cel: Tworzenie kwerend z warunkami i filtrowaniem danych.

Zadanie:

  1. Utwórz tabelę Klienci z kolumnami:
    • ID_Klienta (INT, Primary Key),
    • Imię (VARCHAR(50)),
    • Nazwisko (VARCHAR(50)),
    • Email (VARCHAR(100)),
    • Miasto (VARCHAR(50)).
  2. Wprowadź dane do tabeli Klienci.
  3. Utwórz kwerendę, która wyświetli wszystkich klientów z wybranego miasta (np. "Warszawa").
  4. Stwórz kwerendę, która wyświetli tylko tych klientów, których nazwisko zaczyna się na literę "K".

Przykładowy kod SQL:

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%';

Ćwiczenie 7: Kwerendy z użyciem funkcji

Cel: Wykorzystywanie funkcji w zapytaniach SQL.

Zadanie:

  1. Utwórz tabelę Produkty z kolumnami:
    • ID_Produktu (INT, Primary Key),
    • Nazwa_Produktu (VARCHAR(100)),
    • Cena (DECIMAL(10, 2)).
  2. Wprowadź dane do tabeli Produkty.
  3. Użyj funkcji ROUND(), aby zaokrąglić cenę produktów do dwóch miejsc po przecinku.
  4. Skorzystaj z funkcji CONCAT(), aby połączyć nazwę produktu z jego ceną w jednym wyniku.

Przykładowy kod SQL:

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;

Ćwiczenie 8: Kwerendy z użyciem podzapytań

Cel: Używanie podzapytań w zapytaniach SQL.

Zadanie:

  1. Utwórz tabelę Sprzedawcy z kolumnami:
    • ID_Sprzedawcy (INT, Primary Key),
    • Imię (VARCHAR(50)),
    • Nazwisko (VARCHAR(50)),
    • Wynagrodzenie (DECIMAL(10, 2)).
  2. Wprowadź dane do tabeli Sprzedawcy.
  3. Utwórz zapytanie, które zwróci imiona i nazwiska sprzedawców, którzy zarabiają więcej niż średnia pensja wszystkich sprzedawców.
  4. Skorzystaj z podzapytania w klauzuli WHERE.

Przykładowy kod SQL:

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);

Ćwiczenie 9: Kwerendy z sortowaniem

Cel: Sortowanie danych w zapytaniach SQL.

Zadanie:

  1. Utwórz tabelę Zamówienia z kolumnami:
    • ID_Zamówienia (INT, Primary Key),
    • Data_Zamówienia (DATE),
    • Wartość (DECIMAL(10, 2)).
  2. Wprowadź dane do tabeli Zamówienia.
  3. Utwórz kwerendę, która posortuje zamówienia według daty w porządku rosnącym.
  4. Skorzystaj z funkcji ORDER BY i sortuj zamówienia według wartości w porządku malejącym.

Przykładowy kod SQL:

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;

Ćwiczenie 10: Kwerendy z użyciem JOIN

Cel: Łączenie tabel za pomocą JOIN.

Zadanie:

  1. Utwórz dwie tabele: Produkty i Zamówienia:
    • Produkty: ID_Produktu (INT, Primary Key), Nazwa_Produktu (VARCHAR(100)), Cena (DECIMAL(10, 2)),
    • Zamówienia: ID_Zamówienia (INT, Primary Key), ID_Produktu (INT), Data_Zamówienia (DATE), Ilość (INT).
  2. Wprowadź dane do obu tabel.
  3. Utwórz zapytanie, które połączy tabele Produkty i Zamówienia i wyświetli nazwę produktu, datę zamówienia oraz łączną wartość zamówienia (Cena * Ilość).

Przykładowy kod SQL:

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 Produkty.Nazwa_Produktu, Zamówienia.Data_Zamówienia, (Produkty.Cena * Zamówienia.Ilość) AS Wartość_Zamówienia
FROM Produkty
JOIN Zamówienia ON Produkty.ID_Produktu = Zamówienia.ID_Produktu;

Ćwiczenie 11: Kwerendy z użyciem UNION

Cel: Łączenie wyników zapytań za pomocą UNION.

Zadanie:

  1. Utwórz dwie tabele: Sprzedawcy i Pracownicy:
    • Sprzedawcy: ID_Sprzedawcy (INT, Primary Key), Imię (VARCHAR(50)), Nazwisko (VARCHAR(50)), Wynagrodzenie (DECIMAL(10, 2)),
    • Pracownicy: ID_Pracownika (INT, Primary Key), Imię (VARCHAR(50)), Nazwisko (VARCHAR(50)), Stanowisko (VARCHAR(50)).
  2. Wprowadź dane do obu tabel.
  3. Utwórz zapytanie, które połączy nazwiska pracowników z obu tabel, wyświetlając je razem w jednym wyniku.

Przykładowy kod SQL:

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;

Ćwiczenie 12: Kwerendy z użyciem GROUP BY i HAVING

Cel: Używanie GROUP BY i HAVING w zapytaniach SQL.

Zadanie:

  1. Utwórz tabelę Zamówienia z kolumnami:
    • ID_Zamówienia (INT, Primary Key),
    • ID_Klienta (INT),
    • Wartość (DECIMAL(10, 2)),
    • Data_Zamówienia (DATE).
  2. Wprowadź dane do tabeli Zamówienia.
  3. Utwórz zapytanie, które wyświetli klientów, którzy złożyli zamówienia o łącznej wartości większej niż 1000, posortowane według wartości zamówienia.
  4. Użyj klauzuli GROUP BY oraz HAVING do filtrowania danych.

Przykładowy kod SQL:

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;

Ćwiczenie 13: Kwerendy z użyciem DISTINCT

Cel: Usuwanie duplikatów za pomocą DISTINCT.

Zadanie:

  1. Utwórz tabelę Transakcje z kolumnami:
    • ID_Transakcji (INT, Primary Key),
    • ID_Klienta (INT),
    • Kwota (DECIMAL(10, 2)),
    • Data_Transakcji (DATE).
  2. Wprowadź dane do tabeli Transakcje.
  3. Utwórz zapytanie, które wyświetli unikalne kwoty transakcji.

Przykładowy kod SQL:

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

SELECT DISTINCT Kwota FROM Transakcje;

Ćwiczenie 14: Kwerenda z użyciem CASE

Cel: Użycie wyrażenia warunkowego CASE w zapytaniach SQL.

Zadanie:

  1. Utwórz tabelę Sprzedawcy z kolumnami:
    • ID_Sprzedawcy (INT, Primary Key),
    • Imię (VARCHAR(50)),
    • Sprzedaż (DECIMAL(10, 2)),
    • Region (VARCHAR(50)).
  2. Wprowadź dane do tabeli Sprzedawcy.
  3. Utwórz zapytanie, które wyświetli nazwiska sprzedawców oraz ich klasyfikację na podstawie sprzedaży:
    • Jeśli sprzedaż przekracza 5000, klasyfikacja to "Top Seller".
    • Jeśli sprzedaż wynosi między 2000 a 5000, klasyfikacja to "Average Seller".
    • Jeśli sprzedaż jest mniejsza niż 2000, klasyfikacja to "Low Seller".

Przykładowy kod SQL:

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;

Ćwiczenie 15: Kwerendy z użyciem Subqueries

Cel: Użycie zapytań podrzędnych (subqueries) w SQL.

Zadanie:

  1. Utwórz dwie tabele: Produkty i Zamówienia z poniższymi kolumnami:
    • Produkty: ID_Produktu (INT, Primary Key), Nazwa (VARCHAR(100)), Cena (DECIMAL(10, 2)),
    • Zamówienia: ID_Zamówienia (INT, Primary Key), ID_Produktu (INT), Ilość (INT).
  2. Wprowadź dane do obu tabel.
  3. Utwórz zapytanie, które wyświetli produkty, których cena jest wyższa niż średnia cena wszystkich produktów.

Przykładowy kod SQL:

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);

Ćwiczenie 16: Kwerendy z użyciem ALTER TABLE

Cel: Modyfikowanie struktury tabeli za pomocą ALTER TABLE.

Zadanie:

  1. Utwórz tabelę Studenci z kolumnami:
    • ID_Studenta (INT, Primary Key),
    • Imię (VARCHAR(50)),
    • Nazwisko (VARCHAR(50)),
    • Rok_Urodzenia (YEAR).
  2. Wprowadź dane do tabeli Studenci.
  3. Po wprowadzeniu danych dodaj nową kolumnę Email (VARCHAR(100)) do tabeli Studenci.
  4. Uaktualnij tabelę, aby kolumna Email mogła przechowywać wartości NULL.

Przykładowy kod SQL:

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;

Ćwiczenie 17: Kwerendy z użyciem TRUNCATE

Cel: Usuwanie danych z tabeli za pomocą TRUNCATE.

Zadanie:

  1. Utwórz tabelę Magazyn z kolumnami:
    • ID_Produktu (INT, Primary Key),
    • Nazwa (VARCHAR(100)),
    • Ilość (INT),
    • Cena (DECIMAL(10, 2)).
  2. Wprowadź dane do tabeli Magazyn.
  3. Użyj polecenia TRUNCATE, aby usunąć wszystkie dane z tabeli Magazyn.

Przykładowy kod SQL:

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

TRUNCATE TABLE Magazyn;

Ćwiczenie 18: Kwerendy z użyciem DELETE

Cel: Usuwanie danych z tabeli za pomocą DELETE.

Zadanie:

  1. Utwórz tabelę Klienci z kolumnami:
    • ID_Klienta (INT, Primary Key),
    • Imię (VARCHAR(50)),
    • Nazwisko (VARCHAR(50)),
    • Adres (VARCHAR(100)),
    • Miasto (VARCHAR(50)).
  2. Wprowadź dane do tabeli Klienci.
  3. Użyj zapytania, które usunie klientów z miasta "Warszawa".

Przykładowy kod SQL:

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';

Ćwiczenie 19: Kwerendy z użyciem IN

Cel: Użycie operatora IN w zapytaniach SQL.

Zadanie:

  1. Utwórz tabelę Produkty z kolumnami:
    • ID_Produktu (INT, Primary Key),
    • Nazwa (VARCHAR(100)),
    • Cena (DECIMAL(10, 2)).
  2. Wprowadź dane do tabeli Produkty.
  3. Użyj zapytania, które wyświetli produkty, których ceny należą do zestawu wartości: (100, 200, 300).

Przykładowy kod SQL:

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);

Ćwiczenie 20: Kwerendy z użyciem JOIN

Cel: Łączenie tabel za pomocą zapytań SQL.

Zadanie:

  1. Utwórz dwie tabele: Klienci i Zamówienia z poniższymi kolumnami:
    • Klienci: ID_Klienta (INT, Primary Key), Imię (VARCHAR(50)), Nazwisko (VARCHAR(50)).
    • Zamówienia: ID_Zamówienia (INT, Primary Key), ID_Klienta (INT), Data (DATE), Kwota (DECIMAL(10, 2)).
  2. Wprowadź dane do obu tabel.
  3. Użyj zapytania, które połączy tabelę Klienci z tabelą Zamówienia na podstawie kolumny ID_Klienta i wyświetli nazwiska klientów oraz daty ich zamówień.

Przykładowy kod SQL:

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 Klienci.Nazwisko,
    Zamówienia.Data
FROM Klienci
INNER JOIN Zamówienia ON Klienci.ID_Klienta = Zamówienia.ID_Klienta;

Ćwiczenie 21: Kwerendy z użyciem UNION

Cel: Łączenie wyników z różnych zapytań za pomocą UNION.

Zadanie:

  1. Utwórz dwie tabele: Klienci_A i Klienci_B z kolumnami:
    • ID_Klienta (INT, Primary Key), Imię (VARCHAR(50)), Nazwisko (VARCHAR(50)), Miasto (VARCHAR(50)).
  2. Wprowadź dane do obu tabel.
  3. Użyj zapytania, które połączy dane z obu tabel, wyświetlając nazwiska klientów z miast "Warszawa" lub "Kraków".

Przykładowy kod SQL:

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';

Ćwiczenie 22: Kwerendy z użyciem GROUP BY

Cel: Grupowanie wyników zapytania za pomocą `GROUP BY`.

Zadanie:

  1. Utwórz tabelę Zamówienia z kolumnami:
    • ID_Zamówienia (INT, Primary Key),
    • ID_Klienta (INT),
    • Data (DATE),
    • Kwota (DECIMAL(10, 2)).
  2. Wprowadź dane do tabeli Zamówienia.
  3. Użyj zapytania, które wyświetli sumę kwot zamówień zgrupowaną według ID_Klienta.

Przykładowy kod SQL:

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;

Ćwiczenie 23: Kwerendy z użyciem HAVING

Cel: Użycie klauzuli `HAVING` do filtrowania wyników po grupowaniu.

Zadanie:

  1. Utwórz tabelę Zamówienia z kolumnami:
    • ID_Zamówienia (INT, Primary Key),
    • ID_Klienta (INT),
    • Data (DATE),
    • Kwota (DECIMAL(10, 2)).
  2. Wprowadź dane do tabeli Zamówienia.
  3. Użyj zapytania, które wyświetli sumę kwot zamówień zgrupowaną według ID_Klienta, ale tylko dla tych klientów, których suma zamówień przekroczyła 500.

Przykładowy kod SQL:

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;

Ćwiczenie 24: Kwerendy z użyciem ORDER BY

Cel: Sortowanie wyników zapytania za pomocą `ORDER BY`.

Zadanie:

  1. Utwórz tabelę Produkty z kolumnami:
    • ID_Produktu (INT, Primary Key),
    • Nazwa (VARCHAR(100)),
    • Cena (DECIMAL(10, 2)).
  2. Wprowadź dane do tabeli Produkty.
  3. Użyj zapytania, które wyświetli produkty posortowane malejąco według ceny.

Przykładowy kod SQL:

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

SELECT Nazwa,
    Cena
FROM Produkty
ORDER BY Cena DESC;

Ćwiczenie 25: Kwerendy z użyciem LIMIT

Cel: Ograniczenie liczby zwróconych wyników za pomocą `LIMIT`.

Zadanie:

  1. Utwórz tabelę Produkty z kolumnami:
    • ID_Produktu (INT, Primary Key),
    • Nazwa (VARCHAR(100)),
    • Cena (DECIMAL(10, 2)).
  2. Wprowadź dane do tabeli Produkty.
  3. Użyj zapytania, które wyświetli 5 najtańszych produktów.

Przykładowy kod SQL:

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;