Database Assignment

Q #1) What are Inner JOINS used in SQL? Explain with Syntax

Inner Joins in SQL

An Inner Join in SQL is used to combine data from two or more tables based on a
shared column containing matching values. expand more It retrieves only the records
that have matches in both tables.
Syntax:
SQL
SELECT *
FROM table1
INNER JOIN table2 ON table1.column1 = table2.column2;
Explanation of the syntax:
SELECT *: Selects all columns from both tables (you can specify specific columns if
desired).
FROM table1: Specifies the first table involved in the join.
INNER JOIN table2: Indicates that an inner join will be performed.
ON table1.column1 = table2.column2: This clause specifies the join condition. It
compares the values in column1 of table1 with the values in column2 of table2. Only
rows where the values in both columns match are included in the final result.
Example:
Consider the tables you provided:

Emp_ld, Last_Name, First_Name, Job Role (from the first table: Emp_details)
Emp_ld, Last_Name, First_Name, Joining_Date (from the second table:
Emp_details2)
They both have a common column, Emp_ld. We can use an inner join to combine
information about employees (including their job role) with their joining dates. Here's
the query:
select
emp_details.emp_id,emp_details.Last_name,Emp_details.First_name,Job_role,j
oining_date from emp_details inner join emp_details2 on
emp_details.Last_name=emp_details2.last_name AND
emp_details.first_name=emp_details2.First_name;

+--------+-----------+------------+----------------+--------------+-----------------+----+
| emp_id | Last_name |First_name | Job_role | joining_date |
+--------+-----------+------------+----------------+--------------+-----------------+-----+
| E0011 | Varma | Akhil | Administration | 2016-04-18 |
| E0012 | Samson | Nikita | Asst.Manager | 2016-04-19 |
| E0013 | Jordon | Nil | incharge | 2016-05-01 |

+--------+-----------+------------+----------------+--------------+--------------------+
Q #2) What are Left JOINS used in SQL? Explain with Syntax

Left Joins in SQL

A left join is a type of join used in SQL to combine data from two or more tables based
on a related column. In a left join, all rows from the left table are included in the result
set, even if there is no matching row in the right table. For rows in the right table that
don't have a match in the left table, the corresponding columns in the right table will be
filled with null values.

Left Join Syntax

The basic syntax for a left join in SQL is as follows:

SELECT *
FROM left_table
LEFT JOIN right_table
ON left_table.column_name = right_table.column_name;

In this syntax:

SELECT * selects all columns from both tables. You can also specify the columns you
want to select instead of using *.
left_table is the table that will provide all the rows in the result set.
right_table is the table that will be joined with the left table.
ON left_table.column_name = right_table.column_name is the join condition that
specifies how the tables will be joined. The columns specified in the ON clause must
have compatible data types.
They both have a common column, Emp_ld. We can use a left join to combine
information about employees (including their job role) with their joining dates. Here's
the query:

select
emp_details.emp_id,emp_details.Last_name,Emp_details.First_name,Job_role,j
oining_date from emp_details left join emp_details2 on
emp_details.Last_name=emp_details2.last_name AND
emp_details.first_name=emp_details2.First_name;
+--------+-----------+------------+----------------+--------------+------------------+
| emp_id | Last_name | First_name | Job_role | joining_date |
+--------+-----------+------------+----------------+--------------+------------------+
| E0011 | Varma | Akhil | Administration | 2016-04-18 |
| E0012 | Samson | Nikita | Asst.Manager | 2016-04-19 |
| E0013 | Jordon | Nil | incharge | 2016-05-01 |
| E0014 | Smith | Joe | Technician | NULL |
+--------+-----------+------------+----------------+--------------+------------------+
 Q #3) What are Right JOINS used in SQL? Explain with Syntax

A right join in SQL is a type of join used to combine data from two tables based on a
matching column. Unlike an inner join that returns only matching rows from both
tables, a right join prioritizes including all rows from the right table. It also includes
matching rows from the left table, but if there's no match in the left table, the
corresponding columns will be filled with NULL values.

Here's the basic syntax for a right join:

SELECT *
FROM table1
RIGHT JOIN table2 ON table1.column1 = table2.column2;

 SELECT *: This selects all columns from both tables. You can also specify individual
columns instead of *.
 FROM table1: This specifies the first table involved in the join.
 RIGHT JOIN table2: This keyword indicates a right join operation is being performed
on the second table (table2).
 ON table1.column1 = table2.column2: This clause defines the join condition. Rows
from both tables are matched based on the equality
of column1 in table1 and column2 in table2.
 Key points about right joins:

 All rows from the right table are included in the result, even if there's no match in the
left table.
 Matching rows from the left table are also included.
 Unmatched rows from the left table will have NULL values in the corresponding
columns.

Right joins are useful when you want to ensure all data from the right table is included
in the result, even if there's no corresponding data in the left table. This can be helpful
for analyzing data from a specific table and identifying missing information in the other
table.

select
emp_details.emp_id,emp_details.Last_name,Emp_details.First_name,Job_role,j
oining_date from emp_details right join emp_details2 on
emp_details.Last_name=emp_details2.last_name AND
emp_details.first_name=emp_details2.First_name;

+--------+-----------+------------+----------------+--------------+----------------+
| emp_id | Last_name | First_name | Job_role | joining_date |
+--------+-----------+------------+----------------+--------------+----------------+
| E0011 | Varma | Akhil | Administration | 2016-04-18 |
| E0012 | Samson | Nikita | Asst.Manager | 2016-04-19 |
| E0013 | Jordon | Nil | incharge | 2016-05-01 |
| NULL | NULL | NULL | NULL | 2016-03-01 |
+--------+-----------+------------+----------------+--------------+-----------------+

Q #4) What are Full JOINS used in SQL? Explain with Syntax
A full join in SQL is a join operation that combines all rows from both participating
tables. It includes matching rows from both tables (like an inner join) and unmatched
rows from either table (filling in with NULL values for the missing columns).
Here's how a full join works:
It retrieves all rows from the left table and all rows from the right table.
For matching rows (based on the join condition), it includes the corresponding values
from both tables.
For rows that don't have a match in the other table, it fills the missing columns with
NULL values.
This essentially combines the results of a left outer join and a right outer join.
Syntax:
SELECT *
FROM table1
FULL OUTER JOIN table2 ON table1.column1 = table2.column2;

Explanation of the syntax:

 SELECT *: Selects all columns from both tables (you can specify individual columns
instead of "*").
 FROM table1: The first table involved in the join.
 FULL OUTER JOIN table2: This keyword indicates a full outer join operation is being
performed on the second table (table2).
 ON table1.column1 = table2.column2: This clause defines the join condition. Rows
from both tables are matched based on the equality
of column1 in table1 and column2 in table2.

Key points about full joins:

 Includes all rows from both tables.

 Matching rows have corresponding values from both tables.
 Unmatched rows have NULL values in the columns from the missing table.

Use cases for full joins:

 Analyzing complete datasets from two tables, even if there are missing matches.
 Identifying missing information in one table compared to the other.
 Getting a comprehensive view of data from both tables, regardless of matches.
Q #5)
Q1 Write an SQL query to fetch the current date-time from the system.

There are common functions you can use to fetch the current date-time from the
system:

CURRENT_TIMESTAMP: This function is more widely supported across various

database platforms like MySQL, PostgreSQL, Oracle, etc.

Query:

SELECT CURRENT_TIMESTAMP;
+------------------------------------+
| CURRENT_TIMESTAMP |
+------------------------------------+
| 2024-03-27 19:38:04 |
+------------------------------------+
 Q2. Find the Nth highest consultation fees from the PatientsCheckup table
with 4 and without using the TOP/LIMIT keywords.

solution to find the Nth highest consultation fee from the PatientsCheckup table
without using TOP/LIMIT keywords in MySQL:

1. Find the Nth Highest Consultation Fee: We can utilize a subquery to achieve this.
The subquery will find all distinct consultation fees ordered by descending order. We
can then use another query to find the Nth distinct fee from this result.

SELECT DISTINCT (SELECT DISTINCT ConsultationFees FROM PatientsCheckup

ORDER BY ConsultationFees DESC LIMIT N-1, 1) AS NthHighestFee FROM

PatientsCheckup;

Here's a solution to find the Nth highest consultation fee from the PatientsCheckup
table without using TOP/LIMIT keywords in MySQL:

Find the Nth Highest Consultation Fee: We can utilize a subquery to achieve this. The
subquery will find all distinct consultation fees ordered by descending order. We can
then use another query to find the Nth distinct fee from this result.

Explanation:

The subquery:

SELECT DISTINCT ConsultationFees FROM PatientsCheckup retrieves all the

distinct consultation fees from the PatientsCheckup table.

ORDER BY ConsultationFees DESC sorts the fees in descending order, placing the
highest fee first.

LIMIT N-1, 1 limits the result to one record, starting from the (N-1)th position. This
ensures we retrieve the Nth highest distinct fee.

The outer query:

The outer query uses SELECT DISTINCT with an empty table to act as a
placeholder.The main clause (SELECT DISTINCT ConsultationFees ... ) AS
NthHighestFee retrieves the Nth highest fee identified by the subquery and assigns it
an alias NthHighestFee.

Example:

Assuming you want the 4th highest consultation fee (i.e., N = 4), the query would be:

SELECT DISTINCT (SELECT DISTINCT ConsultationFees FROM

PatientsCheckup ORDER BY ConsultationFees DESC LIMIT 3, 1) AS
4thHighestFee FROM PatientsCheckup;

+---------------------+

| 4thHighestFee |

+---------------------+

| 300 |

+----------------------+

Q3. Write a query to fetch top N records using the TOP/LIMIT,

ordered by Consultation Fees

MySQL doesn't support the TOP keyword for limiting results. However, you can
achieve the same functionality using the LIMIT clause. Here's the query to fetch the
top N records ordered by Consultation Fees in MySQL:

SELECT *
FROM PatientsCheckup
ORDER BY ConsultationFees DESC
LIMIT N;
 Explanation:

1. SELECT *: This selects all columns from the PatientsCheckup table. You can
replace * with specific column names if needed.
2. ORDER BY ConsultationFees DESC: This clause sorts the results by
the ConsultationFees column in descending order, placing the highest fees first.
3. LIMIT N: This clause limits the number of returned rows to N. Replace N with the
desired number of top records you want to fetch.

Example:

To fetch the top 5 consultations with the highest fees:

SELECT *

FROM PatientsCheckup

ORDER BY ConsultationFees DESC

LIMIT 5;

This query will return the details of the 5 consultations with the highest consultation
fees in the PatientsCheckup table.

+-------------+-----------+-----------+-------------------------+

| PatientID | BP | Weight | ConsultationFees |

+----------- +-----------+-----------+--------------------------+

| 5 | 143/67 | 78 | 700 |

| 4 | 160/81 | 61 | 550 |

| 2 | 142/76 | 78 | 400 |

| 1 | 121/80 | 67 | 300 |

| 3 | 151/75 | 55 | 300 |

+-------------+----------+------------+-------------------------+
Q4. Write a query to fetch even and odd rows from a table.
Fetching Even Rows:

SELECT *

FROM PatientsCheckup

WHERE MOD(column_name, 2) = 0;

Explanation:

SELECT *: This selects all columns from the PatientsCheckup table. You can replace
* with specific column names if needed.

WHERE MOD(column_name, 2) = 0: This clause filters the results.

MOD(column_name, 2) calculates the remainder when the value in the column_name

column is divided by 2.

= 0 checks if the remainder is 0. If so, the row represents an even-numbered position

based on the column values (assuming the column values represent a sequential
order).

Fetching Odd Rows:

SELECT *

FROM PatientsCheckup

WHERE MOD(PatientID, 2) <> 0;

Explanation:
SELECT *: This selects all columns from the PatientsCheckup table. You can replace
* with specific column names if needed.

WHERE MOD(column_name, 2) = 0: This clause filters the results.

MOD(column_name, 2) calculates the remainder when the value in the column_name

column is divided by 2.

= 0 checks if the remainder is 0. If so, the row represents an even-numbered position

based on the column values (assuming the column values represent a sequential
order).

Fetching Odd Rows:

SELECT *

FROM PatientsCheckup

WHERE MOD(PatientID, 2) <> 0;

Explanation:

This query is similar to the even rows query, but the condition uses <> 0 to select rows
where the remainder is not equal to 0, which represents odd-numbered positions
based on the column values.