EXPERIMENT NO.

4
Ques- Write the queries for implementing Built-in
functions, GROUP BY, HAVING and ORDER BY.

Creating a table
CREATE TABLE Sales
(
ProductID INT,
ProductName VARCHAR(50),
Quantity INT,
Price DECIMAL(10, 2)
);
INSERT INTO Sales (ProductID, ProductName, Quantity, Price) VALUES
(1, 'Product A', 5, 10.00),
(2, 'Product B', 3, 15.00),
(1, 'Product A', 2, 10.00),
(3, 'Product C', 1, 20.00),
(2, 'Product B', 4, 15.00);

BUILT IN FUNCTIONS
SELECT ProductID, ProductName, SUM(Quantity * Price) AS TotalSales
FROM Sales
GROUP BY ProductID, ProductName;

GROUP BY
SELECT ProductID, ProductName, COUNT(*) AS SalesCount
FROM Sales
GROUP BY ProductID, ProductName;

HAVING
SELECT ProductID, ProductName, SUM(Quantity * Price) AS TotalSales
FROM Sales
GROUP BY ProductID, ProductName
HAVING SUM(Quantity * Price) > 50;
ORDER BY
SELECT ProductID, ProductName, SUM(Quantity * Price) AS TotalSales
FROM Sales
GROUP BY ProductID, ProductName
ORDER BY TotalSales DESC;
 EXPERIMENT 5
Ques- Write the queries to implement the joins.
CREATING TWO TABLES
CREATE TABLE Customers (
CustomerID INT PRIMARY KEY,
FirstName VARCHAR(50),
LastName VARCHAR(50),
Email VARCHAR(100)
);
CREATE TABLE Orders (
OrderID INT PRIMARY KEY,
CustomerID INT,
OrderDate DATE,
TotalAmount DECIMAL(10, 2),
FOREIGN KEY (CustomerID) REFERENCES Customers(CustomerID)
);
-- Insert into Customers table
INSERT INTO Customers (CustomerID, FirstName, LastName, Email)
VALUES
(1, 'John', 'Doe', 'john.doe@example.com'),
(2, 'Jane', 'Smith', 'jane.smith@example.com'),
(3, 'David', 'Brown', 'david.brown@example.com');
-- Insert into Orders table
INSERT INTO Orders (OrderID, CustomerID, OrderDate, TotalAmount)
VALUES
(101, 1, '2024-04-01', 150.00),
(102, 2, '2024-04-02', 200.00),
(103, 1, '2024-04-03', 100.00),
(104, 3, '2024-04-04', 300.00);

INNER JOIN
SELECT Orders.OrderID, Customers.FirstName, Customers.LastName,
Orders.OrderDate, Orders.TotalAmount
FROM Orders
INNER JOIN Customers ON Orders.CustomerID = Customers.CustomerID;
LEFT JOIN
SELECT Customers.FirstName, Customers.LastName, Orders.OrderID,
Orders.OrderDate, Orders.TotalAmount
FROM Customers
LEFT JOIN Orders ON Customers.CustomerID = Orders.CustomerID;

RIGHT JOIN
SELECT Orders.OrderID, Customers.FirstName, Customers.LastName,
Orders.OrderDate, Orders.TotalAmount
FROM Orders
RIGHT JOIN Customers ON Orders.CustomerID = Customers.CustomerID;
FULL OUTER JOIN
SELECT Customers.FirstName, Customers.LastName, Orders.OrderID,
Orders.OrderDate, Orders.TotalAmount
FROM Customers
FULL OUTER JOIN Orders ON Customers.CustomerID = Orders.CustomerID;
 EXPERIMENT 6
Ques- Write the queries to implement the subqueries

Creating table
CREATE TABLE Employees (
EmployeeID INT PRIMARY KEY,
FirstName VARCHAR(50),
LastName VARCHAR(50),
DepartmentID INT
);
INSERT INTO Employees (EmployeeID, FirstName, LastName,
DepartmentID) VALUES
(1, 'John', 'Doe', 101),
(2, 'Jane', 'Smith', 102),
(3, 'David', 'Brown', 101),
(4, 'Mary', 'Johnson', 103),
(5, 'Michael', 'Williams', 102);
SUBQUERY IN SELECT CLAUSE
SELECT DepartmentID, (
SELECT COUNT(*)
FROM Employees
WHERE DepartmentID = Employees.DepartmentID
) AS NumEmployees
FROM Employees;

SUBQUERY IN WHERE CLAUSE

SELECT EmployeeID, FirstName, LastName, DepartmentID
FROM Employees
WHERE DepartmentID = (
SELECT DepartmentID
FROM Employees
WHERE FirstName = 'John' AND LastName = 'Doe'
);
 EXPERIMENT 7
QUES- Write the queries to implement the set
operations
Creating 1st table:
CREATE TABLE Employees_A (
EmployeeID INT PRIMARY KEY,
FirstName VARCHAR(50),
LastName VARCHAR(50),
Department VARCHAR(50),
Salary DECIMAL(10, 2),
City VARCHAR(50)
)
INSERT INTO Employees_A (EmployeeID, FirstName, LastName,
Department, Salary, City) VALUES
(1, 'John', 'Doe', 'IT', 60000.00, 'New York'),
(2, 'Jane', 'Smith', 'HR', 55000.00, 'Los Angeles'),
(3, 'David', 'Brown', 'Finance', 70000.00, 'Chicago'),
(4, 'Mary', 'Johnson', 'Marketing', 65000.00, 'Houston'),
(5, 'Michael', 'Williams', 'IT', 62000.00, 'San Francisco');
CREATE TABLE Employees_B (
EmployeeID INT PRIMARY KEY,
FirstName VARCHAR(50),
LastName VARCHAR(50),
Department VARCHAR(50),
Salary DECIMAL(10, 2),
City VARCHAR(50)
)
INSERT INTO Employees_B (EmployeeID, FirstName, LastName,
Department, Salary, City) VALUES
(6, 'Sarah', 'Clark', 'Marketing', 60000.00, 'Dallas'),
(7, 'Robert', 'White', 'Finance', 72000.00, 'Miami'),
(1, 'John', 'Doe', 'IT', 60000.00, 'New York'),
(9, 'James', 'Martinez', 'Marketing', 63000.00, 'Boston'),
(3, 'David', 'Brown', 'Finance', 70000.00, 'Chicago');
UNION
SELECT * FROM Employees_A
UNION
SELECT * FROM Employees_B;

INTERSECT
SELECT * FROM Employees_A
INTERSECT
SELECT * FROM Employees_B;

EXCEPT
-- Employees in Employees_A but not in Employees_B
SELECT * FROM Employees_A
EXCEPT
SELECT * FROM Employees_B;
 EXPERIMENT 9
Ques-Demonstrate the concept of control structures
Using IF….ELSE:
CREATE TABLE Employees (
EmployeeID INT PRIMARY KEY,
Name NVARCHAR(50),
Salary INT
);
INSERT INTO Employees (EmployeeID, Name, Salary)
VALUES (1, 'Piyush Dalal', 60000),
(2, 'Kartik Sharma', 45000);
CREATE PROCEDURE CheckEmployeeSalary (@EmployeeID INT)
AS
BEGIN
DECLARE @Salary INT;
SELECT @Salary = Salary FROM Employees WHERE EmployeeID =
@EmployeeID;
IF @Salary > 50000
BEGIN
PRINT 'The salary is above the threshold.';
END
ELSE
BEGIN
PRINT 'The salary is below the threshold.';
 END
END;
EXEC CheckEmployeeSalary 1;
EXEC CheckEmployeeSalary 2;

OUTPUT

Using CASE:
SELECT EmployeeID, Name,
CASE
WHEN Salary > 50000 THEN 'High Salary'
WHEN Salary BETWEEN 30000 AND 50000 THEN 'Medium Salary'
ELSE 'Low Salary'
END AS SalaryCategory
FROM Employees;

OUTPUT
Using WHILE LOOP:
CREATE PROCEDURE GiveRaise(@PercentageIncrease DECIMAL(5, 2))
AS
BEGIN
DECLARE @EmployeeID INT;
DECLARE @Salary INT;
DECLARE EmployeeCursor CURSOR FOR
SELECT EmployeeID, Salary FROM Employees;
OPEN EmployeeCursor;
FETCH NEXT FROM EmployeeCursor INTO @EmployeeID, @Salary;
WHILE @@FETCH_STATUS = 0
BEGIN
UPDATE Employees
SET Salary = Salary + (Salary * @PercentageIncrease / 100)
WHERE EmployeeID = @EmployeeID;
FETCH NEXT FROM EmployeeCursor INTO @EmployeeID, @Salary;
END;
CLOSE EmployeeCursor;
DEALLOCATE EmployeeCursor;
END;
EXEC GiveRaise 10;
SELECT * FROM Employees;
OUTPUT

Using BEGIN…END:
-- Create a sample Accounts table
CREATE TABLE Accounts (
AccountID INT PRIMARY KEY,
Balance DECIMAL(18, 2)
);
INSERT INTO Accounts (AccountID, Balance)
VALUES (1, 1000.00),
(2, 2000.00);
CREATE PROCEDURE TransferFunds (@FromAccountID INT,
@ToAccountID INT, @Amount DECIMAL(18, 2))
AS
BEGIN
BEGIN TRANSACTION;
BEGIN TRY

UPDATE Accounts
SET Balance = Balance - @Amount
WHERE AccountID = @FromAccountID;
 UPDATE Accounts
SET Balance = Balance + @Amount
WHERE AccountID = @ToAccountID;
COMMIT TRANSACTION;
PRINT 'Transaction completed successfully.';
END TRY
BEGIN CATCH
ROLLBACK TRANSACTION;
PRINT 'Error occurred during the transaction. Transaction rolled back.';
END CATCH
END;
EXEC TransferFunds 1, 2, 500.00;
SELECT * FROM Accounts;

OUTPUT
 EXPERIMENT 10
Ques-Demonstrate the concept of exception handling

CREATE TABLE Accounts (

AccountID INT PRIMARY KEY,
Balance DECIMAL(18, 2)
);
INSERT INTO Accounts (AccountID, Balance)
VALUES (1, 1000.00), (2, 2000.00);

CREATE PROCEDURE TransferFunds (@FromAccountID INT,

@ToAccountID INT, @Amount DECIMAL(18, 2))
AS
BEGIN
BEGIN TRANSACTION;
BEGIN TRY
UPDATE Accounts
SET Balance = Balance - @Amount
WHERE AccountID = @FromAccountID;
UPDATE Accounts
SET Balance = Balance + @Amount
WHERE AccountID = @ToAccountID;
COMMIT TRANSACTION;
PRINT 'Transaction completed successfully.';
END TRY
 BEGIN CATCH
ROLLBACK TRANSACTION;
PRINT 'Error: ' + ERROR_MESSAGE();
END CATCH
END;
EXEC TransferFunds 1, 2, 500.00;

OUTPUT

SELECT * FROM Accounts;

EXEC TransferFunds 1, 3, 500.00;

 EXPERIMENT 11
Ques-Demonstrate the concept of Functions And
Procedures
Creating and Using a Stored Procedure

CREATE TABLE Employees (

EmployeeID INT PRIMARY KEY,
Name NVARCHAR(50),
Salary INT
);
INSERT INTO Employees (EmployeeID, Name, Salary)
VALUES (1, 'Piyush Dalal', 60000),
(2, 'Kartik Sharma', 45000);
CREATE PROCEDURE GetEmployeeDetails (@EmployeeID INT)
AS
BEGIN
SELECT EmployeeID, Name, Salary
FROM Employees
WHERE EmployeeID = @EmployeeID;
END;
EXEC GetEmployeeDetails 1;
EXEC GetEmployeeDetails 2;
OUTPUT

Creating and Using a User-Defined Function

CREATE FUNCTION GetEmployeeSalary (@EmployeeID INT)

RETURNS INT
AS
BEGIN
DECLARE @Salary INT;
SELECT @Salary = Salary FROM Employees WHERE EmployeeID =
@EmployeeID;
RETURN @Salary;
END;
SELECT Name, dbo.GetEmployeeSalary(EmployeeID) AS Salary
FROM Employees;
OUTPUT

Creating and Using a Table-Valued Function

CREATE FUNCTION GetEmployeesBySalaryRange (@MinSalary INT,

@MaxSalary INT)
RETURNS TABLE
AS
RETURN
(
SELECT EmployeeID, Name, Salary
FROM Employees
WHERE Salary BETWEEN @MinSalary AND @MaxSalary
);
SELECT * FROM dbo.GetEmployeesBySalaryRange(40000, 65000);

OUTPUT
 EXPERIMENT 12
Ques-Demonstrate the use of Triggers.
CREATE TABLE employees (
employee_id INT PRIMARY KEY,
name VARCHAR(100),
salary DECIMAL(10, 2)
);
CREATE TRIGGER update_salary
AFTER INSERT ON employees
FOR EACH ROW
BEGIN
IF NEW.salary < 50000 THEN
SET NEW.salary = NEW.salary * 1.1; -- Increase salary by 10%
END IF;
END;
INSERT INTO employees (employee_id, name, salary) VALUES
(1, 'Piyush Dalal', 45000),
(2, 'Aman Saini', 60000);
SELECT * FROM employees;

OUTPUT