select

-------------------------------------------------------------------------------------------------------
--------------------------------------------- Operator SELECT -----------------------------------------
-------------------------------------------------------------------------------------------------------
-- започваме с най-простата заявка, селектираме всичко от таблица
SELECT * FROM COUNTRIES
-------------------------------------------------------------------------------------------------------
-- ORDER BY подрежда резултат по посочената колона във възх.ред ASC (default)/ низх.ред DESC.
SELECT * FROM COUNTRIES ORDER BY NAME ASC
SELECT * FROM COUNTRIES ORDER BY NAME DESC

-- забележете в резултатния набор, че след като се подреди възх. по номера на региона
-- има и повтаряне на номера (напр.4), там вече се подрежда по COUNTRY_ID  в низх.ред
SELECT * FROM COUNTRIES ORDER BY REGION_ID ASC, COUNTRY_ID DESC

-------------------------------------------------------------------------------------------------------
--EMPLOYEES Подредени по фамилно име – възходящо и низходящо;
SELECT * FROM EMPLOYEES ORDER BY LNAME ASC
SELECT * FROM EMPLOYEES ORDER BY LNAME DESC
-------------------------------------------------------------------------------------------------------
-- задача:
-- Всички данни за служителите със заплати над 12000 годишно;
SELECT *
  FROM EMPLOYEES
 WHERE SALARY > 12000
 -------------------------------------------------------------------------------------------------------
-- задача:
-- Общата сума на годишните заплати
SELECT SUM(SALARY)              -- използваме агрегатна функция SUM()
  FROM EMPLOYEES

-------------------------------------------------------------------------------------------------------
-- задача:
-- Общата сума от заплатите на всички служители, наети след определена дата
SELECT SUM(SALARY)
  FROM EMPLOYEES
 WHERE HIRE_DATE > '1998-06-21'

-------------------------------------------------------------------------------------------------------
-- задача:
-- Общата сума от заплатите на всички служители, групирани по отдели, където работят
SELECT SUM(SALARY)
FROM EMPLOYEES
GROUP BY DEPARTMENT_ID

-- случва се следното: всички служители с еднакъв DEPARTMENT_ID стават група и заплатите им се сумират по група

-- в резултатния набор ни излизат числа, но не знaем на кой отдел съответстват, можем да го запишем в селекта
-- При групиране в Select може да има освен агрегиращи функции и колоните, по които се групира.
SELECT SUM(SALARY), DEPARTMENT_ID
FROM EMPLOYEES
GROUP BY DEPARTMENT_ID

-------------------------------------------------------------------------------------------------------
-- задача:
-- Общите суми на заплатите по отдели, средната заплата за всеки отдел, минимална и
-- максимална заплата в отдел, както и брой на служители във всеки отдел (групирани по отдели).

SELECT DEPARTMENT_ID,
       SUM(SALARY) AS SUM_SALARY,     -- as = alies , което буквално значи като, и слага име на колоната
       AVG(SALARY)    AVG_SALARY,     -- може и да се пише as, може и да се пропусне as и да се напише само съкращението
       MAX(SALARY)    [MAX SALARY],
       MIN(SALARY) AS [MIN SALARY],
       COUNT(*) --AS COUNT_EMP
FROM EMPLOYEES
GROUP BY DEPARTMENT_ID

-- Ще видите и надолу в примерите, че често пропускаме AS и изписваме само избраното от нас съкращение
-- Целта да се използва, за да се именуват колони с No column name (както в COUNT(*) - виж резултата),
-- за да дадем избрано от нас име на колона, която няма име в резултатния набор

--------------------------------------------------------------------------------------------------

-- задача:
-- Всички клиенти, чието първо име е Fred
SELECT *
  FROM CUSTOMERS
 WHERE FNAME = 'Fred'

-------------------------------------------------------------------------------------------
-- задача:
-- Всички клиенти, чиeто име започва с “Fre”.
SELECT *
  FROM CUSTOMERS
 WHERE FNAME LIKE 'Fre%'

-- операторът LIKE е разширение на сравняването на низове (=)
-- като са добавени възможности за задаване на маски в низа, който се търси.
-- Символът ‘%’ означава, че на негово място може да бъде произволен низ.
-- В случая се намират всички низове, които започват с низа “Fre”.

-------------------------------------------------------------------------------------------------------
-------------------------------------------Вложени заявки----------------------------------------
-------------------------------------------------------------------------------------------------------

--Наричат се подзаявки, защото в една зяавка буквално се влага друга заявка и резултатът от вложената се използва
--като операнд във външната. Това се дължи на факта, че резултатът от прилагането на релационен оператор е отново релация.

-- ЗАДАЧА 1:
--Да се изведе име и фамилия на всички клиенти, които са от държави от регион 3.

SELECT FNAME, LNAME, COUNTRY_ID
  FROM CUSTOMERS
 WHERE COUNTRY_ID IN (SELECT COUNTRY_ID        -- изпълнете само вътрешната заявка и вижте какво връща
                        FROM COUNTRIES         -- връща COUNTRIES_ID-тата, които имат region_ID = 3,
                       WHERE REGION_ID = 3 )


 -- Външ.завка използва този резултат, за да ограничи крайният резултат само до тези клиенти,
 -- чиито държави са сред върнатите от вложената заявка


-------------------------------------------------------------------------------------------------------
-------------------------------------------UNION----------------------------------------
-------------------------------------------------------------------------------------------------------
--Обединява резултати от 2 или повече заявки в един резултат(съдържащ всички редове от заявките)

--  Правила за резултатните набори, които обединяваме:
--- Броят и редът на колоните на заявките, чиито резултати обединяваме, трябва да бъде еднакъв за всички заявки;
--- Типовете данни на колоните, чиито данни обединяваме, трябва да бъдат съвместими, ако първата колона от заявките
--  е число, то първите колони във всички заявки трябва да бъдат от числов тип, и така до последната колона от заявките;
--- В целия израз може да присъства само една клауза ORDER BY накрая, сортираща всички обединени резултатни набори.

-- По подразбиране UNION премахва дублиращите се редове!
-- Ако все пак искаме и тях използваме UNION ALL

-- ЗАДАЧА 2:
-- Да се изведе информация за:
-- а). Всички малки имена в нашата база;
SELECT FNAME FROM CUSTOMERS
UNION
SELECT FNAME FROM EMPLOYEES


-- b). Всички имена с евентуалните им повторения, сортирани в низходящ ред;
  SELECT FNAME FROM CUSTOMERS
UNION ALL
  SELECT FNAME FROM EMPLOYEES
ORDER BY 1 DESC

-- при UNION, ORDER BY може да бъде приложен само на обединения резултатен набор,
-- не на отделните заявки. Понеже колоните в отделните заявки могат да имат различни имена,
-- е позволено да укажем ORDER BY по индекс – пр.1 сортираме по първата колона от резултатния набор.


-- c). Всички имена с добавена колона, която ще се изчислява от израз;
-- тук е решението на задачата:
  SELECT FNAME, 'Клиент (' + COUNTRY_ID + ')'
    FROM CUSTOMERS
UNION
  SELECT FNAME, 'Служител (' + CAST(DEPARTMENT_ID AS VARCHAR)+ ')'
    FROM EMPLOYEES
ORDER BY 2 DESC, 1 ASC

            ------------------------Обяснения относно решението на задачата:------------------------
            -- Примера, който използвахме за пояснение на конкатерирането в първата част на обединението
            SELECT 'Петър' + ' Петров'
            SELECT 'Клиент (' + ' 1'+ ' )'

            -- конкатенираме низ + колона с идентификатори(напр: BG, US) + отново низ
            SELECT 'Петър' + COUNTRY_ID + ' Петров' -- enter
            FROM CUSTOMERS
            --------------------------------------------------
            -- Пояснение за втората част от обединението:
            -- явно преобразуване на един тип в друг чрез скаларна функция CAST
            SELECT CAST(DEPARTMENT_ID AS VARCHAR)
            FROM EMPLOYEES

            --в изразната колона се налага да преобразуваме явно стойността на колонота DEPARTMENT_ID до низ,
            --за да няма двусмислие при прилагане на оператора +, т.е. да бъде интерпретиран като оператор за конкатенация.

            -- CAST изисква( израз КАТО тип, към който да се преобразува )
            -- Случаен страничен пример за пояснение: SELECT CAST (2344 as varchar) + ' стая'

            -- ако изпробвате следната заявка ще се обедите, че без CAST ще даде грешка, защото DEPARTMENT_ID е int
            -- спомнете си, и че има три условия за UNION
            SELECT FNAME, 'Клиент (' + COUNTRY_ID + ')'
            FROM CUSTOMERS
            UNION
            SELECT FNAME, 'Служител (' + DEPARTMENT_ID + ')'
            FROM EMPLOYEES

-------------------------------------------------------------------------------------------------------
-- ЗАДАЧА 3:
--Да се изведе информация за държавите и регионите, в които се намират:

-- нека започнем така
SELECT * FROM COUNTRIES, REGIONS

-- получaваме резултат, който се състои от комбинациите на всеки запис от първата таблица с всеки от втората
-- това е Декартово произведение на двете таблици или т.нар. CROSS JOIN. Естествено в този резултат има неверни данни.
-- Искаме всяка страна да бъде комбинирана с единствения регион, в който тя действително се намира,
-- т.е. искаме да останат само тези записи, които имат съвпадащи стойности в полетата REGION_ID от двете таблици
-- Нека добавим това условие в WHERE клаузата на заявката.

-- решението е следното:
SELECT * FROM COUNTRIES, REGIONS
WHERE COUNTRIES.REGION_ID = REGIONS.REGION_ID
-- в where клаузата добавихме просто условие за съпоставка.

-------------------------------------------------------------------------------------------------------
-------------------------------------------5.3. Operator JOIN----------------------------------------
-------------------------------------------------------------------------------------------------------
-- Можем да съединим две или повече таблици чрез оператора JOIN. За разлика от UNION, чрез който
-- обединявахме редовете от резултатните набори, с JOIN можем да обединим колоните на две или повече таблици.

--Припомнете си видовете съединения (погледнете диаграмите на Вен и mindmap):
--1. CROSS JOIN – връща Декартово произведение на двете таблици.
--2. INNER JOIN - използва се с оператор за сравнение на редове от две т-ци, базирано на стойностите в общи колони за всяка таблица
--3. OUTER JOIN, може да бъде три вида:
    --3.1. ляво  (LEFT OUTER JOIN или LEFT JOIN)- резултата ще включва всички редове от т-цата, отляво на JOIN, не само съвпадащите с дясната таблица.
        -- Ако определен ред от лявата т-ца няма съвпадение в дясната, стойностите на колоните, идващи от дясната т-ца ще бъдат NULL.
    --3.2. дясно (RIGHT OUTER JOIN или RIGHT JOIN) - обратен на left join – всички редове от дясната т-ца, а ако някой от тях няма
        -- съвпадение в лявата таблица, стойностите на колоните, идващи от лявата таблица ще бъдат NULL.
    --3.3. пълно (FULL OUTER JOIN или FULL JOIN) - всички редове от лявата и дясната т-ци. Ако някой от записите от едната таблица няма
        -- съвпадение в другата таблица, колоните, които идват от другата таблица ще съдържат стойности NULL.

-------------------------------------------------------------------------------------------------------
--ЗАДАЧА 4: Да се изведе информация за:
-- а). Страните и регионите, в които се намират, включваща идентификатор, наименование на държава
    -- и наименование на регион, в който се намира. Да се използва вътрешно съединение (тоест INNER JOIN)

-- ЩЕ преработим предната заявка така, че да използва JOIN за правилно извличане на данни от двете таблици.

SELECT COUNTRY_ID, COUNTRIES.NAME, REGIONS.NAME
FROM COUNTRIES /*INNER*/ JOIN REGIONS
ON COUNTRIES.REGION_ID = REGIONS.REGION_ID

-- Забележка: ако пропуснем ключовата дума INNER ще работи по същия начин, защото това е типът съединение по подразбиране.
-- INNER JOIN включва САМО ЗАПИСИТЕ ОТ ТАБЛИЦИТЕ, КОИТО ИМАТ СЪОВЕТСТВИЯ. Така че в резултата няма да има региони, за които
-- не е въведена поне една държава, също и държави, които не са причислени към никой от регионите.

-------------------------------------------------------------------------------------------------------

---- b). В резултат да участват и регионите, за които НЯМА въведени страни:

-- Ще използваме външно съединение, за да бъдат запазени записите за регионите, които нямат съответни в таблицата с държавите.
-- Избираме REGIONS за лява таблица и използваме LEFT OUTER JOIN, защото искаме всички записи от т-цата отляво на JOIN,
-- комбинирани с евентуалните им съответни от т-цата отдясно на JOIN.
-- /Същото ще се получи ако разменим местата на двете таблици и запишем RIGHT OUTER JOIN/- т.е. зависи коя т-ца е пред/зад JOIN

SELECT REGIONS.NAME, COUNTRY_ID, COUNTRIES.NAME
FROM REGIONS LEFT OUTER JOIN COUNTRIES
ON REGIONS.REGION_ID = COUNTRIES.REGION_ID


-- Изпълняваме заявката, скролваме надолу в резултатния набор и виждаме регион, който има NULL, което значи,
-- че в региона няма въведени държави. За него стойностите от COUNTRIES са NULL.

-- За да направим резултатния набор по-прегледен може да използваме функция COALESCE, връщаща първия ненулев аргумент.
-- (вместо NULL, виждаме символ -)
SELECT REGIONS.NAME, COALESCE(COUNTRIES.COUNTRY_ID, '-'), COALESCE(COUNTRIES.NAME, '-')
FROM REGIONS LEFT OUTER JOIN COUNTRIES
ON REGIONS.REGION_ID = COUNTRIES.REGION_ID


-- c). Регионите и страните в тях. В резултатният набор да участват и регионите,
    -- за които НЯМА въведени страни, както и страните, за които НЕ е указан регион:

SELECT COUNTRY_ID, COUNTRIES.NAME, REGIONS.NAME
FROM REGIONS FULL OUTER JOIN COUNTRIES
ON REGIONS.REGION_ID = COUNTRIES.REGION_ID

--Пояснение:
-- в тази заявка се извършва пълно външно съединение на таблици в FROM клаузата.
-- Това означава, че ще участват всички записи от лявата таблица REGIONS, като тези от тях,
-- които нямат съответни в дясната таблица COUNTRIES ще имат стойности NULL в колоните,
-- идващи от дясната таблица. Също ще участват всички записи от дясната таблица
--REGIONS, като тези от тях, които нямат съответни в дясната таблица COUNTRIES ще имат стойности NULL
-- в колоните, идващи от лявата таблица.

-------------------------------------------------------------------------------------------------------
-- ЗАДАЧА 5:
-- Извличане на първите 6 служители с най-ниска заплата;
SELECT TOP 6 *                               -- TOP 6 връща 6 записа от резултатния набор.
FROM EMPLOYEES
ORDER BY SALARY

-- За да вземем тези с най-ниските заплати сме извършили сортировка. Не сме записали след SALARY ASC, защото по подразбиране е
-- ASC и значи, че реда е възходящ, така че първите 6 ще са с най-ниската заплата.

-------------------------------------------------------------------------------------------------------
-- ЗАДАЧА 6:
-- Обаче, ако има и други, които са с равна на 6-я служител заплата, ще се покажат с: WITH TIES
SELECT TOP 6 WITH TIES *
FROM EMPLOYEES
ORDER BY SALARY

-------------------------------------------------------------------------------------------------------
-- ЗАДАЧА 7: Да се изведат:
-- a. Идентификаторите на продуктите и цените, на които са били поръчвани

SELECT OI.PRODUCT_ID, OI.UNIT_PRICE
FROM ORDER_ITEMS AS OI                 -- AS съкращава ORDER_ITEMS на избрано от нас съкращение , в случая OI, с цел да използваме съкращението вместо цялото и име
ORDER BY  OI.PRODUCT_ID

--Пояснение:Тъй като някои продукти са поръчвани повече от веднъж на една и съща цена има дублиращи се редове в резултата.


-- b. Дублажите се премахват с командата DISTINCT:
SELECT DISTINCT OI.PRODUCT_ID, OI.UNIT_PRICE
FROM ORDER_ITEMS OI
ORDER BY OI.PRODUCT_ID

--c. Имената на продуктите, които са били поръчвани
SELECT P.NAME
FROM PRODUCTS P
WHERE EXISTS (SELECT * FROM ORDER_ITEMS OI
              WHERE OI.PRODUCT_ID = P.PRODUCT_ID)
ORDER BY P.NAME

-- За всеки ред от външната заявка EXISTS тества за наличие на редове във вътрешната(която е обвързана с външната в WHERE клаузата си).
-- Ако има редове – редът от външната ще участва в резултата.

-------------------------------------------------------------------------------------------------------
-- ЗАДАЧА 8:
-- Кой клиент колко поръчки е направил до момента.

SELECT C.FNAME, C.LNAME, COUNT(*) ords
FROM CUSTOMERS C JOIN ORDERS O
ON C.CUSTOMER_ID = O.CUSTOMER_ID
GROUP BY C.FNAME, C.LNAME
ORDER BY ords

-- заявката работи добре, стига да не искаме да видим тези, които до момента не са правили поръчки.
-- Ако искаме всички клиенти - без значение поръчали или не, трябва да използваме външно съединение.
-------------------------------------------------------------------------------------------------------
-- ЗАДАЧА 9:
-- Кой клиент колко поръчки е направил до момента.
-- В резултата да участват и тези, които не са правили все още поръчки.
SELECT C.FNAME, C.LNAME, COUNT(*) ords
FROM CUSTOMERS C LEFT JOIN ORDERS O
ON C.CUSTOMER_ID = O.CUSTOMER_ID
GROUP BY C.FNAME, C.LNAME
ORDER BY ords

-- Пояснение: излезе, че всеки е правил поне една поръчка. Това е подвеждащо заради
-- неточността, която сме допуснали: COUNT(*) брои редовете, т.е. за всеки клиент наистина
-- има поне един ред, но ще трябва да накараме функцията да преброи поръчките на клиента,
-- т.е. да  брои ненулевите стойности за всеки
-- клиент в някоя ненулева колона от поръчките: например COUNT(O.ORDER_ID).

SELECT C.FNAME, C.LNAME, COUNT(O.ORDER_ID) ords
FROM CUSTOMERS C LEFT JOIN ORDERS O
ON C.CUSTOMER_ID = O.CUSTOMER_ID
GROUP BY C.FNAME, C.LNAME
ORDER BY ords

-------------------------------------------------------------------------------------------------------
-- ЗАДАЧА 10:
--  Да се изведат всички данни за всички служители, подредени по фамилия във възходящ ред.

SELECT *
FROM EMPLOYEES
ORDER BY LNAME

-------------------------------------------------------------------------------------------------------
-- ЗАДАЧА 11:
--  Да се изведат имената на всички служители и фамилията на прекия им началник, подредени по име на служителя.

--  Пояснение: относно таблица EMPLOYEES правим две aliases (спомнете си как създадохме EMPLOYEES)
SELECT EMP.FNAME, EMP.LNAME, BOSS.LNAME
FROM EMPLOYEES EMP JOIN EMPLOYEES BOSS
ON EMP.MANAGER_ID = BOSS.EMPLOYEE_ID
ORDER BY EMP.LNAME

-------------------------------------------------------------------------------------------------------
-- ЗАДАЧА 12:
-- Да се изведат имената на всички служители и фамилията на прекия им началник, подредени по име на служителя.
-- Вкл. и служителите, КОИТО НЯМАТ началник, --> тоест ползваме външен join (LEFT OUTER JOIN)
-- като за тях вместо нулева стойност в името на началника да има константен низ.

-- в случая низът е '<Няма шеф>' и когато изпълните заявката ще видите, че вместо NULL се изписва <Няма шеф>

SELECT EMP.FNAME, EMP.LNAME, ISNULL(BOSS.LNAME, '<Няма шеф>')
FROM EMPLOYEES EMP LEFT JOIN EMPLOYEES BOSS
ON EMP.MANAGER_ID = BOSS.EMPLOYEE_ID
ORDER BY EMP.LNAME

-------------------------------------------------------------------------------------------------------
-- ЗАДАЧА 13:
-- Да се изведе информация за това кой служител кои поръчки е обработил.
SELECT E.FNAME, E.LNAME, O.ORDER_ID
FROM EMPLOYEES E JOIN ORDERS O
ON E.EMPLOYEE_ID = O.EMPLOYEE_ID
ORDER BY E.LNAME

-------------------------------------------------------------------------------------------------------
-- ЗАДАЧА 14:
-- Кой служител колко поръчки е обработил, подредени по броя на поръчките в низходящ ред.
SELECT E.FNAME, E.LNAME, COUNT(*)
FROM EMPLOYEES E LEFT JOIN ORDERS O
ON E.EMPLOYEE_ID = O.EMPLOYEE_ID
GROUP BY E.FNAME, E.LNAME
ORDER BY 3 DESC          --в у-то подредени по бр. на поръчките в низх.ред. --COUNT(*) е 3-ти подред в селекта, затова пишем 3

-------------------------------------------------------------------------------------------------------
-- ЗАДАЧА 15:
-- Да се изведат всички служители, които са обработили над 4 поръчки до момента.
SELECT E.FNAME, E.LNAME, COUNT(*)
FROM EMPLOYEES E LEFT JOIN ORDERS O
ON E.EMPLOYEE_ID = O.EMPLOYEE_ID
GROUP BY E.FNAME, E.LNAME
HAVING COUNT(*) > 4
ORDER BY 3 DESC

-------------------------------------------------------------------------------------------------------
-- ЗАДАЧА 16:
-- Да се изведе детайлната част на поръчка с Order_ID = 2354
SELECT *
FROM ORDER_ITEMS
WHERE ORDER_ID = 2354

-------------------------------------------------------------------------------------------------------
-- ЗАДАЧА 17:
-- Да се изведе общата сума на поръчка с Order_ID = 2354
 SELECT SUM(UNIT_PRICE*QUANTITY)         -- сумираме единичната цена * количеството, за да получим общата сума
 FROM ORDER_ITEMS
  WHERE Order_ID = 2354

-------------------------------------------------------------------------------------------------------
-- ЗАДАЧА 18:
-- Да се изведат всички поръчки с общата сума на ВСЯКА от тях.
-- Добавяме просто условие за съпоставка в WHERE клаузата. Това е вътрешно съединение между използваните две таблици

SELECT O.ORDER_ID, O.ORDER_DATE, SUM(OI.UNIT_PRICE*OI.QUANTITY)
  FROM ORDERS O, ORDER_ITEMS OI
 WHERE O.ORDER_ID = OI.ORDER_ID
GROUP BY O.ORDER_ID, O.ORDER_DATE
-------------------------------------------------------------------------------------------------------
-- ЗАДАЧА 19:
-- Да се изведат правилите поръчки клиенти заедно с общия брой на поръчките и общата сума на поръчките,
-- направени от всеки от тях, подредени в низходящ ред по сумата от поръчките.

-- Тук вместо две, имаме три таблици, затова условията в WHERE клаузата разделяме с AND
--- COUNT (DISTINCT] expression) – Когато се използва DISTINCT връща броя на уникалните и различни от NULL стойности;

SELECT C.FNAME,
       C.LNAME,
       COUNT(DISTINCT O.ORDER_ID) Ords,
       SUM(OI.UNIT_PRICE*OI.QUANTITY) AS Total
  FROM CUSTOMERS C, ORDERS O, ORDER_ITEMS OI
 WHERE C.CUSTOMER_ID = O.CUSTOMER_ID
   AND O.ORDER_ID = OI.ORDER_ID
 GROUP BY C.FNAME, C.LNAME
 ORDER BY Total DESC


 -------------------------------------------------------------------------------------------------------
-- ЗАДАЧА 20:
-- Да се разшири предната задача, но само клиенти с поръчки на стойност над 100 000.

SELECT C.FNAME,
       C.LNAME,
       COUNT(O.ORDER_ID) Ords,
       SUM(OI.UNIT_PRICE*OI.QUANTITY) AS Total
  FROM CUSTOMERS C, ORDERS O, ORDER_ITEMS OI
 WHERE C.CUSTOMER_ID = O.CUSTOMER_ID
   AND O.ORDER_ID = OI.ORDER_ID
 GROUP BY C.FNAME, C.LNAME
HAVING SUM(OI.UNIT_PRICE*OI.QUANTITY) !< 100000            --  !< е знака за не по-малко
 ORDER BY Total DESC

-------------------------------------------------------------------------------------------------------
-- ЗАДАЧА 21:
-- Да се изведат СЛУЖИТЕЛИТЕ, които са обработили поръчки за над 100 000.

    SELECT E.FNAME,
           E.LNAME,
           COUNT(O.ORDER_ID) Ords,
           SUM(OI.UNIT_PRICE*OI.QUANTITY) AS Total
      FROM EMPLOYEES E, ORDERS O, ORDER_ITEMS OI
     WHERE E.EMPLOYEE_ID = O.EMPLOYEE_ID
       AND O.ORDER_ID = OI.ORDER_ID
  GROUP BY E.FNAME, E.LNAME
    HAVING SUM(OI.UNIT_PRICE*OI.QUANTITY) > 100000
  ORDER BY Total DESC

-------------------------------------------------------------------------------------------------------
-- ЗАДАЧА 22:
-- Да се изведат име на продукт и общо продадено количество за продукта.

SELECT P.NAME,
       SUM(OI.QUANTITY) AS TotalSold
  FROM PRODUCTS P, ORDER_ITEMS OI
 WHERE P.PRODUCT_ID = OI.PRODUCT_ID
 GROUP BY P.NAME
 ORDER BY TotalSold DESC