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

---------------------------------------------------
--SUB QUERIES - A subquery (or nested query) in SQL is a query within another
query. It is used to perform operations that cannot be done in a single query and
helps break down complex operations into simpler ones. Subqueries can be used in
the SELECT, FROM, WHERE, and HAVING clauses.
--Types of Subqueries:Single-Row Subquery, Multi-Row Subquery, Multi-Column
Subquery AND Correlated Subquery
--SYNTAX: SELECT column_name FROM table_name WHERE column_name operator (SELECT
column_name FROM another_table WHERE condition);
-----------------------------------------------------------------------------------
-------------------------------------------------
--single-row subquery returns exactly one row and one column.

--QUERY;Find the customer who is the oldest.

SQL> SELECT * FROM CUSTOMER;

CUS_NAME CUS_CITY PHONE EMAIL

DOB AGE SUP_NAME
-------------------- -------------------- ----------
----------------------------------- --------- ---------- --------------------
KAVI MADURAI
43
RAVI SIVAKASI
35
PAVI CHENNAI
45
ARUN MADURAI
23 KAVI
VARUN MADURAI
28 KAVI
MARUN ERODE
28 PAVI
PARUN CHENNAI
32 PAVI
SARUN TRICHY
28 KAVI

8 rows selected.

SQL> SELECT CUS_NAME, AGE FROM CUSTOMER WHERE AGE = (SELECT MAX(AGE) FROM
CUSTOMER);

CUS_NAME AGE
-------------------- ----------
PAVI 45

--QUERY:Find the customer who is older than the average age of all customers.
SQL> SELECT CUS_NAME, AGE FROM CUSTOMER WHERE AGE > (SELECT AVG(AGE) FROM
CUSTOMER);

CUS_NAME AGE
-------------------- ----------
KAVI 43
RAVI 35
PAVI 45
--multi-row subquery returns multiple rows. It’s typically used with operators like
IN, ANY, or ALL.
--QUERY: Find customers who live in the same cities as customers who are aged 40 or
older.

SQL> SELECT CUS_NAME, CUS_CITY FROM CUSTOMER WHERE CUS_CITY IN (SELECT CUS_CITY
FROM CUSTOMER WHERE AGE >= 40);

CUS_NAME CUS_CITY
-------------------- --------------------
KAVI MADURAI
ARUN MADURAI
VARUN MADURAI
PAVI CHENNAI
PARUN CHENNAI

--QUERY:Find customers who live in the same city as KAVI.

SQL> SELECT CUS_NAME, CUS_CITY FROM CUSTOMER WHERE CUS_CITY IN (SELECT CUS_CITY
FROM CUSTOMER WHERE CUS_NAME = 'KAVI');

CUS_NAME CUS_CITY
-------------------- --------------------
KAVI MADURAI
ARUN MADURAI
VARUN MADURAI

--QUERY:Find customers who are younger than any customer with an age greater than
30.
SQL> SELECT CUS_NAME, AGE FROM CUSTOMER WHERE AGE < ANY (SELECT AGE FROM CUSTOMER
WHERE AGE > 30);

CUS_NAME AGE
-------------------- ----------
ARUN 23
SARUN 28
VARUN 28
MARUN 28
PARUN 32
RAVI 35
KAVI 43

7 rows selected.

--QUERY:Find the names and ages of customers who are younger than every customer
whose age is greater than 30

SQL> SELECT CUS_NAME, AGE FROM CUSTOMER WHERE AGE < ALL (SELECT AGE FROM CUSTOMER
WHERE AGE > 30);

CUS_NAME AGE
-------------------- ----------
SARUN 28
VARUN 28
MARUN 28
ARUN 23

--QUERY:Find customers who are older than all customers with an age greater than
20.
SQL> SELECT CUS_NAME, AGE FROM CUSTOMER WHERE AGE > ALL (SELECT AGE FROM CUSTOMER
WHERE AGE > 20);

no rows selected

--multi-column subquery returns more than one column. It can be used with IN or
EXISTS

--QUERY:Find customers who live in the same city as any customer with the name
"KAVI".

SQL> SELECT C1.CUS_NAME, C1.CUS_CITY FROM CUSTOMER C1 WHERE (C1.CUS_CITY) IN

(SELECT C2.CUS_CITY FROM CUSTOMER C2 WHERE C2.CUS_NAME = 'KAVI');

CUS_NAME CUS_CITY
-------------------- --------------------
KAVI MADURAI
ARUN MADURAI
VARUN MADURAI

--QUERY:Find customers whose supervisor lives in the same city as them.

SQL> SELECT C1.CUS_NAME, C1.CUS_CITY, C1.SUP_NAME FROM CUSTOMER C1 WHERE

(C1.CUS_CITY, C1.SUP_NAME) IN (SELECT C2.CUS_CITY, C2.CUS_NAME FROM CUSTOMER C2
WHERE C1.SUP_NAME = C2.CUS_NAME);

CUS_NAME CUS_CITY SUP_NAME

-------------------- -------------------- --------------------
ARUN MADURAI KAVI
VARUN MADURAI KAVI
PARUN CHENNAI PAVI

-- correlated subquery is one where the inner query refers to columns from the
outer query. It is evaluated once for each row processed by the outer query.
--QUERY:Find customers who are younger than their supervisor.
SQL> SELECT C1.CUS_NAME, C1.AGE FROM CUSTOMER C1 WHERE C1.AGE < (SELECT C2.AGE FROM
CUSTOMER C2 WHERE C1.SUP_NAME = C2.CUS_NAME);

CUS_NAME AGE
-------------------- ----------
ARUN 23
VARUN 28
MARUN 28
PARUN 32
SARUN 28
ALLEN 42

6 rows selected.

SQL> UPDATE CUSTOMER SET AGE=50 WHERE CUS_NAME='ALLEN';

1 row updated.

SQL> SELECT * FROM CUSTOMER;

CUS_NAME CUS_CITY PHONE EMAIL

DOB AGE SUP_NAME
-------------------- -------------------- ----------
----------------------------------- --------- ---------- --------------------
KAVI MADURAI
43
RAVI SIVAKASI
35
PAVI CHENNAI
45
ARUN MADURAI
23 KAVI
VARUN MADURAI
28 KAVI
MARUN ERODE
28 PAVI
PARUN CHENNAI
32 PAVI
SARUN TRICHY
28 KAVI
ALLEN MADURAI
50 PAVI

9 rows selected.

SQL> SELECT C1.CUS_NAME, C1.AGE FROM CUSTOMER C1 WHERE C1.AGE < (SELECT C2.AGE FROM
CUSTOMER C2 WHERE C1.SUP_NAME = C2.CUS_NAME);

CUS_NAME AGE
-------------------- ----------
ARUN 23
VARUN 28
MARUN 28
PARUN 32
SARUN 28

--Subquery in the FROM Clause

--QUERY: List the total number of customers in each city.

SQL> SELECT CUS_CITY, COUNT(*) AS NUM_CUSTOMERS FROM (SELECT CUS_CITY FROM

CUSTOMER) C GROUP BY CUS_CITY;

CUS_CITY NUM_CUSTOMERS
-------------------- -------------
MADURAI 4
SIVAKASI 1
CHENNAI 2
ERODE 1
TRICHY 1

--Subquery in the SELECT Clause

--QUERY: For each customer, display their age and the average age of their city.

SQL> SELECT C1.CUS_NAME, C1.CUS_CITY, C1.AGE,(SELECT AVG(AGE) FROM CUSTOMER C2

WHERE C2.CUS_CITY = C1.CUS_CITY) AS AVG_CITY_AGE FROM CUSTOMER C1;

CUS_NAME CUS_CITY AGE AVG_CITY_AGE

-------------------- -------------------- ---------- ------------
KAVI MADURAI 43 36
ARUN MADURAI 23 36
VARUN MADURAI 28 36
ALLEN MADURAI 50 36
RAVI SIVAKASI 35 35
PAVI CHENNAI 45 38.5
PARUN CHENNAI 32 38.5
MARUN ERODE 28 28
SARUN TRICHY 28 28

9 rows selected.

--Subquery in the HAVING Clause

--QUERY: Find cities where the average age of customers is greater than 30

SQL> SELECT CUS_CITY, AVG(AGE) AS AVG_AGE FROM CUSTOMER GROUP BY CUS_CITY HAVING
AVG(AGE) > (SELECT AVG(AGE) FROM CUSTOMER);

CUS_CITY AVG_AGE
-------------------- ----------
MADURAI 36
SIVAKASI 35
CHENNAI 38.5

--Subquery with EXISTS

--QUERY - Find customers who have a supervisor (i.e., whose supervisor name exists
in the SUP_NAME column)

SQL> SELECT CUS_NAME, SUP_NAME FROM CUSTOMER C1 WHERE EXISTS (SELECT 1 FROM
CUSTOMER C2 WHERE C1.SUP_NAME = C2.CUS_NAME);

CUS_NAME SUP_NAME
-------------------- --------------------
ARUN KAVI
VARUN KAVI
MARUN PAVI
PARUN PAVI
SARUN KAVI
ALLEN PAVI

6 rows selected.
--QUERY: Find customers who live in the same city as any other customer.

SQL> SELECT C1.CUS_NAME, C1.CUS_CITY FROM CUSTOMER C1 WHERE EXISTS (SELECT 1 FROM
CUSTOMER C2 WHERE C1.CUS_CITY = C2.CUS_CITY AND C1.CUS_NAME != C2.CUS_NAME);

CUS_NAME CUS_CITY
-------------------- --------------------
ARUN MADURAI
VARUN MADURAI
ALLEN MADURAI
PARUN CHENNAI
KAVI MADURAI
PAVI CHENNAI

6 rows selected.

--QUERY:Find customers who do not have a supervisor

SQL> SELECT CUS_NAME, CUS_CITY FROM CUSTOMER C1 WHERE NOT EXISTS (SELECT 1 FROM
CUSTOMER C2 WHERE C1.SUP_NAME = C2.CUS_NAME);

CUS_NAME CUS_CITY
-------------------- --------------------
KAVI MADURAI
RAVI SIVAKASI
PAVI CHENNAI

--WITH clause define temporary result sets (which can be treated like tables) that
can be referenced multiple times within a query
--QUERY:find the average age of customers and then find customers whose age is
above the average.

SQL> WITH AvgAge AS (SELECT AVG(AGE) AS avg_age FROM CUSTOMER) SELECT CUS_NAME, AGE
FROM CUSTOMER WHERE AGE > (SELECT avg_age FROM AvgAge);

CUS_NAME AGE
-------------------- ----------
KAVI 43
RAVI 35
PAVI 45
ALLEN 50

--MULTIPLE WITH CLAUSE

--QUERY: display customers whose age is above the average and who live in a city
with more than 2 customers

SQL> WITH AvgAge AS (

2 SELECT AVG(AGE) AS avg_age
3 FROM CUSTOMER
4 ),
5 CityCount AS (
6 SELECT CUS_CITY, COUNT(*) AS city_count
7 FROM CUSTOMER
8 GROUP BY CUS_CITY
9 )
10 SELECT C1.CUS_NAME, C1.AGE, C2.CUS_CITY, C2.city_count
11 FROM CUSTOMER C1
12 JOIN CityCount C2 ON C1.CUS_CITY = C2.CUS_CITY
13 WHERE C1.AGE > (SELECT avg_age FROM AvgAge)
14 AND C2.city_count > 2;

CUS_NAME AGE CUS_CITY CITY_COUNT

-------------------- ---------- -------------------- ----------
KAVI 43 MADURAI 4
ALLEN 50 MADURAI 4

--scalar subquery is a subquery that returns a single value (one row and one
column). It can be used anywhere an expression is expected, such as in the SELECT,
WHERE, or HAVING clauses.
--Using Scalar Subquery in SELECT
--QUERY:fetch a list of customer names and their SUERVISOR names, but only for
customers who live in a specific city, like 'MADURAI'

SQL> SELECT CUS_NAME, (SELECT SUP_NAME FROM CUSTOMER WHERE CUS_NAME = 'VARUN') AS
SUPERVISOR_NAME FROM CUSTOMER WHERE CUS_CITY = 'MADURAI';

CUS_NAME SUPERVISOR_NAME
-------------------- --------------------
KAVI KAVI
ARUN KAVI
VARUN KAVI
ALLEN KAVI
SQL> SELECT CUS_NAME, (SELECT SUP_NAME FROM CUSTOMER WHERE CUS_NAME = 'KAVI') AS
SUPERVISOR_NAME FROM CUSTOMER WHERE CUS_CITY = 'MADURAI';

CUS_NAME SUPERVISOR_NAME
-------------------- --------------------
KAVI
ARUN
VARUN
ALLEN
--Using Scalar Subquery in WHERE Clause to Compare Ages

SQL> SELECT CUS_NAME, AGE FROM CUSTOMER WHERE AGE > (SELECT AVG(AGE) FROM
CUSTOMER);

CUS_NAME AGE
-------------------- ----------
KAVI 43
RAVI 35
PAVI 45
ALLEN 50