IIMT ENGINEERING COLLEGE,

MEERUT,(U.P.)

Recognized by AICTE and Approved by Dr. APJ AKTU, Lucknow

DEPARTMENT OF COMPUTER SCIENCE AND

ENGINNERING

PRACTICAL FILE

SESSION (2024-2025)

NAME- AVNEET ROLL NO.- 2201270100028

BRANCH- CSE SECTION-A

COMPUTER NETWORK

SUBJECT CODE-BCS653 SUBMITTED TO- MR. TARUN AWASTHI

 INDEX

Program
No. Program Name Date Signature

To install SQL Server on a Windows machine,

1
Creating E-R Diagram Using the Case Tool Draw. in
( Customer –Order-Shipment )
2
Writing SQL Statement Using Oracle/SQL.
1. Writing the basic SQL statement .
2. Restricting and sorting data.
3. Displaying the data from multiple table.
3
4. Manipulating the data .
5. Creating and managing the table.

Normalization of a Table

4
Creating the Procedure & Function.
5
Creating the Trigger & Package.
6
Creating the View and explain.
7
T Creating Database and Describe the Join Operation in
8 SQL..

9 To implement the concept cursor in SQL.

To implement the basics of PL/SQL.

10
white the step of automatic backup file and recovery file in
11 SQL

PRACTICAL No: - 01
To install SQL Server on a Windows machine, follow these steps:

1. Download SQL Server Installer

 Go to the official Microsoft SQL Server download page.
 Choose the version you want to install (e.g., SQL Server 2022, SQL Server Express, or Developer Edition).

 Click the Download button and choose the Basic or Custom installation option depending on your
preference.

2. Run the SQL Server Installer

 Once the installer is downloaded, double-click the executable file to launch the installation process.
 If prompted by the Windows User Account Control (UAC), click Yes to allow the installer to make changes.

3. Choose Installation Type

 In the SQL Server Installation Center, click on New SQL Server stand-alone installation or add feature to
an existing installation.

4. Accept the License Terms

 Review the license terms and select I accept the license terms.
 Click Next to continue.

5. Choose Feature(s) to Install

 In the Feature Selection screen, select the components you want to install (e.g., SQL Server Database
Engine, SQL Server Replication, Full-Text and Semantic Extractions, etc.).
 For a typical installation, you can select the Database Engine Services feature. Click Next.

6. Choose Instance Name

 In the Instance Configuration screen, you can choose the default instance or a named instance.
o Default instance name: MSSQLSERVER

o Named instance: You can give it a custom name.

 Click Next to proceed.

7. Server Configuration
 Set the SQL Server Agent to Automatic or Manual based on your requirements.
 Configure the authentication mode:

o Windows Authentication: Uses your Windows account for access.

o Mixed Mode: Allows both Windows Authentication and SQL Server Authentication. You will need
to set a password for the sa (system administrator) account.

 Add the SQL Server administrators by clicking Add Current User (or manually adding users).

 Click Next.

8. Choose Installation Location

 You can specify where SQL Server will be installed (by default, it will install to C:\Program Files\
Microsoft SQL Server\).
 Click Next.
 9. Choose Data Directories
 You can specify the directories for SQL Server data, logs, and backup files. You can leave them as default or
change them if needed.
 Click Next.

10. Choose Feature Installation

 If you selected any additional features, configure them as needed.
 Click Next.

11. Install
 Review all the settings and click Install to begin the installation.
 The installer will start installing SQL Server and related components.

12. Complete the Installation

 Once the installation process is complete, the Install Success page will appear.
 Click Next, and then Close to exit the installer.

13. Install SQL Server Management Studio (SSMS)

 If you selected the Database Engine Services, you will likely want to install SQL Server Management Studio
(SSMS) to manage your SQL Server.
 Download SSMS from the official Microsoft SSMS download page.

 Run the installer, and follow the prompts to complete the installation.

14. Connect to SQL Server

 Once installation is complete, launch SQL Server Management Studio (SSMS).
 In the Connect to Server dialog, enter:

o Server Name: (either the default instance or the name of the instance you configured).

o Authentication Mode: (choose either Windows Authentication or SQL Server Authentication

based on your configuration).

 Click Connect to access the SQL Server.

15. Verify Installation

 Once connected to SQL Server in SSMS, run the following query to verify the installation:
 SELECT @@VERSION;
 This will return the version of SQL Server, confirming that it was installed successfully.

PRACTICAL No: - 02
Objective: Creating E-R Diagram Using the Case Tool Draw. in ( Customer –Order-
Shipment )

Tabular Form of E-R Diagram of Customer –Order- Product

CREATE TABLE CUST_V

(
CUSTOMER_ID NUMBER PRIMARY KEY NOT NULL ENABLE,
 CUST_FIRST_NAME VARCHAR2(20) NOT NULL ENABLE,
CUST_LAST_NAME VARCHAR2(20) NOT NULL ENABLE,
CUST_STREET_ADDRESS1 VARCHAR2(60),
CUST_STREET_ADDRESS2 VARCHAR2(60),
CUST_CITY VARCHAR2(30),
CUST_STATE VARCHAR2(2),
CUST_POSTAL_CODE VARCHAR2(10),
PHONE_NUMBER1 VARCHAR2(25),
PHONE_NUMBER2 VARCHAR2(25),
CREDIT_LIMIT NUMBER(9,2),
CUST_EMAIL VARCHAR2(30));

Explanation:
 CUSTOMER_ID: A numeric field for the unique ID of the customer. It is marked as NOT NULL and should be
the primary key for the table (though this is not explicitly stated in the code).
 CUST_FIRST_NAME and CUST_LAST_NAME: These are required fields (NOT NULL), each having a
maximum length of 20 characters.

 CUST_STREET_ADDRESS1 and CUST_STREET_ADDRESS2: These store the customer's address lines with
a maximum length of 60 characters each.

 CUST_CITY: The customer's city, with a maximum length of 30 characters.

 CUST_STATE: A 2-character field to store the state code.

 CUST_POSTAL_CODE: A postal code with a maximum length of 10 characters.

 PHONE_NUMBER1 and PHONE_NUMBER2: Fields for phone numbers with a maximum length of 25
characters.

 CREDIT_LIMIT: A numeric field for the customer's credit limit, which allows up to 9 digits with 2 decimal
places.

 CUST_EMAIL: The customer's email address, with a maximum length of 30 characters.

To create an ORDER table where CUSTOMER_ID is a foreign key (referring to the CUSTOMER109 table) and
ORDER_ID is the primary key,
SQL for the ORDER Table:

CREATE TABLE ORDER_V

(
ORDER_ID NUMBER NOT NULL ENABLE,
CUSTOMER_ID NUMBER NOT NULL ENABLE,
ORDER_DATE DATE NOT NULL,
SHIP_DATE DATE,
SHIP_ADDRESS VARCHAR2(100),
ORDER_TOTAL NUMBER(10, 2),
CONSTRAINT PK_ORDER_ID PRIMARY KEY (ORDER_ID),
CONSTRAINT FK_CUSTOMER_ID FOREIGN KEY (CUSTOMER_ID) REFERENCES
CUST_R(CUSTOMER_ID)
);

Explanation:
 ORDER_ID: This is the primary key for the order. It is a numeric value and must be unique for each order.
 CUSTOMER_ID: This is the foreign key that references the CUSTOMER_ID in the CUSTOMER109 table,
establishing the relationship between customers and their orders.

 ORDER_DATE: The date when the order was placed. It is a required field.

 SHIP_DATE: The date when the order was shipped (optional).

 SHIP_ADDRESS: The address where the order is shipped. You can adjust the size (currently 100 characters)
based on your needs.

 ORDER_TOTAL: The total amount of the order, defined with two decimal places (e.g., NUMBER(10,2)
allows values up to 99999999.99).

Constraints:
 PK_ORDER_ID: This constraint enforces that ORDER_ID is the primary key and unique.
 FK_CUSTOMER_ID: This constraint ensures that CUSTOMER_ID is a valid reference to the CUSTOMER_ID
field in the CUSTOMER109 table.

To create a SHIPMENT table that is related to the ORDER109 table, you would typically include fields that describe
the shipment, such as the shipment ID, the ORDER_ID (which will be a foreign key), shipment status, tracking
number, and shipment date, among others.
SQL for the SHIPMENT Table:

CREATE TABLE SHIPMENT_V

(
SHIPMENT_ID NUMBER PRIMARY KEY NOT NULL ENABLE,
ORDER_ID NUMBER NOT NULL ENABLE,
SHIP_DATE DATE NOT NULL,
DELIVERY_DATE DATE,
SHIP_METHOD VARCHAR2(50),
TRACKING_NUMBER VARCHAR2(50),
SHIP_STATUS VARCHAR2(30),
SHIP_ADDRESS VARCHAR2(100),
CONSTRAINT PK_SHIPMENT_ID PRIMARY KEY (SHIPMENT_ID),
CONSTRAINT FK_ORDER_ID FOREIGN KEY (ORDER_ID) REFERENCES ORDER_V(ORDER_ID));

Explanation:
 SHIPMENT_ID: This is the primary key for the shipment, uniquely identifying each shipment.
 ORDER_ID: This is a foreign key that links to the ORDER109 table's ORDER_ID field. It ensures that each
shipment is associated with an order.

 SHIP_DATE: The date the shipment is sent. This field is mandatory.

 DELIVERY_DATE: The date when the shipment is delivered (optional).

 SHIP_METHOD: The shipping method (e.g., "Standard", "Express", etc.).

 TRACKING_NUMBER: A field to store the tracking number for the shipment, which is optional but
commonly used.

 SHIP_STATUS: A field that tracks the shipment's current status (e.g., "Shipped", "In Transit", "Delivered").

 SHIP_ADDRESS: The address where the shipment is being sent, which may differ from the billing address.

Constraints:
 PK_SHIPMENT_ID: This constraint enforces that SHIPMENT_ID is unique and serves as the primary key.
 FK_ORDER_ID: This constraint establishes the foreign key relationship, ensuring that each shipment is
linked to an existing order from the ORDER109 table.
E-R Diagram to show the Relationship and Entity
 PRACTICAL No: - 03

Objective: Writing SQL Statement Using Oracle/SQL.

a) Writing the basic SQL statement .
b) Restricting and sorting data.
c) Displaying the data from multiple table.
d) Manipulating the data .
e) Creating and managing the table.

CREATE TABLE EmployeeS (

emp_no NUMBER(5) NOT NULL,
emp_name VARCHAR2(30),
designation CHAR(10),
doj DATE,
salary NUMERIC(9,2),
address VARCHAR2(30),
dept_name CHAR(30)
);

Insert into EmployeeS (emp_no,emp_name,designation,doj,salary,address,dept_name)

VALUES ('1001','Shivam chaudhary','Officer','12-21-1975','1000','Mumbai','Marketing'),
('1002','shwetank','clerk','06-14-1972','500','delhi','Accounts'),
('1003','Vansh tyagi','Manager','12-23-1974','3500','Bombay','Sales'),
('1004','Vishal','Analyst','08-22-1990','5000','Mathura','Software'),
('1005','savej','Analyst','06-22-1991','4900','Delhi','Production'),
('1006','sagar','Clerk','04-16-1986','950','Delhi','Production');

SELECT *FROM EmployeeS;

SQL QUERIES:
1. List the Empname,doj from employeeS table.
SELECT emp_name,doj FROM employeeS;

2. List the names of Employee whois getting 1000Rs.

SELECT emp_name FROM employeeS WHERE salary=3500;

3. List the name of emp who belong to Bombay and depart nameis Sales.
SELECT emp_name FROM employeeS WHERE address='Mumbai' AND dept_name ='Marketing';

4. List the average salary of vinay.

SELECT avg(salary)FROM employeeS WHERE emp_name='Shivam chaudhary';

5. List the name of the emp who are getting their salary between 800 and 2500.
6. SELECT emp_name FROM employeeV WHERE salary BETWEEN 800 AND 2500;

7. List the employees who are earning more than 1200 but less than 4000.
SELECT emp_name FROM employeeS WHERE salary>1200 and salary<4000;

8. List the employees who have joinedfter1-Jan-84intheorderofthejoiningdate.

SELECT emp_name FROM employeeS WHERE doj>('06-22-1990');
9. List the employees who located at Bombay.
SELECT emp_name FROM employeeS WHERE address='Bombay';

10. List the employees who are in sales dept.

SELECT emp_name FROM employeeS WHERE

PRACTICAL No: - 04

Objective: Normalization a Table

A practical of normalization, we are building a database to store information about students, courses,
and enrollments in a school system. We'll demonstrate how to normalize the database from an
unnormalized state (1NF) to higher forms of normalization (2NF, 3NF).

Example 1: Unnormalized Database (0NF)

Initially, we have a simple table that contains all the data about students, their courses, and grades.
The data might look like this:
 Student_ID Student_Name Course_1 Grade_1 Course_2 Grade_2
1001 Shivam Math A Science B
1002 Sagar pal Math C History B

This table violates the First Normal Form (1NF), which requires that each field contain only atomic
values (no repeating groups or arrays). Here, the courses and grades for each student are stored in
separate columns, which violate 1NF.

Step 1: First Normal Form (1NF)

To bring this table into 1NF, we need to remove the repeating groups (i.e., multiple courses and
grades). Each row should contain only atomic values, so we'll separate each course and grade into a
new row:

Student_ID Student_Name Course Grade

1001 Shivam Math A
1001 Shivam Science B
Now, each field 1002 Sagar pal Math C contains only atomic
values, and the table 1002 Sagar pal History B is in 1NF.

Step 2: Second Normal Form (2NF)

To bring the table into 2NF, we need to eliminate partial dependencies. A partial dependency
occurs when a non-key column depends only on part of the primary key, rather than the whole key.

In this case, Student_Name depends only on Student_ID, not on Course or Grade. The primary key
is composite (both Student_ID and Course), and Student_Name depends only on Student_ID, so we
need to split the table into two:

Students Table (holds information about students):

Student_ID Student_Name
1001 Shivam
1002 Sagar pal

Enrollments Table (holds information about enrollments and grades):

Student_ID Course Grade

1001 Math A
1001 Science B
1002 Math C
 Student_ID Course Grade
1002 History B

Now, the database is in 2NF because all non-key attributes depend on the whole primary key
(Student_ID and Course), and there are no partial dependencies.

Step 3: Third Normal Form (3NF)

To bring the database into 3NF, we need to remove transitive dependencies. A transitive
dependency occurs when a non-key column depends on another non-key column.

In the Enrollments table, there is no transitive dependency between Course and Grade, but if we
added a Instructor column, we might see a transitive dependency: the Instructor depends on Course,
and the Course is dependent on the primary key (Student_ID, Course).

To remove transitive dependencies, we would split the table further into:

Students Table (remains unchanged):

Student_ID Student_Name
1001 Shivam
1002 Sagar pal

Courses Table (holds information about courses):

Course Instructor
Math Dr. Anurag
Science Mohit
History Dr. Sunder

Enrollments Table (holds information about student enrollments):

Student_ID Course Grade

1001 Math A
1001 Science B
1002 Math C
1002 History B

Now, the Enrollments table no longer contains any redundant information about instructors, and all
attributes are non-transitively dependent on the primary key, so the database is in 3NF.
 Summary of Normalization Steps
 0NF: Normalized, repeating groups of data.
 1NF: Eliminate repeating groups; make fields atomic.
 2NF: Eliminate partial dependencies by splitting the table into related entities.
 3NF: Eliminate transitive dependencies.

This process reduces redundancy and ensures that the data is organized efficiently. When designing
a database for a real-world application, these normalization steps are critical for maintaining data
integrity and avoiding anomalies when updating or deleting records.

PRACTICAL No: - 05

Objective: Creating the Procedure & Function.

A PL/SQL procedure is a named block of code that performs a specific task, but it does not return
a value. It can take input parameters, perform operations (such as querying or modifying the
database), and return output through parameters or via side effects (like inserting, updating, or
deleting data).

Here is an overview of how to create and use procedures in PL/SQL:

Basic Syntax for Creating a Procedure:

A simple PL/SQL procedure has the following structure:

 CREATE PROCEDURE: This creates a new procedure. You can use OR REPLACE if you want to
replace an existing procedure with a new definition.

 Procedure Name: The name of the procedure being created.

 Parameter List (Optional): You can specify parameters that the procedure can accept,
which can be IN, OUT, or IN OUT.
  IS / AS: This indicates the start of the procedure’s declaration part, where you can define
variables, constants, or exceptions.

 BEGIN / END: These marks the body of the procedure where the actual processing logic
occurs.

Creating a Simple Procedure Example:

Here is an example of a procedure that adds two numbers and prints the result:

 Num1 and num2 are input parameters of type NUMBER.

 Result is a local variable used to store the sum.

 DBMS_OUTPUT.PUT_LINE is used to print the result.

Executing a Procedure:

To execute a procedure in PL/SQL, you simply call it using an anonymous block, or you can use
SQL*Plus or any PL/SQL interface to invoke the procedure.

BEGIN

greetings;

END;
 Dropping a Procedure:

PRACTICAL No: - 06

Objective: Creating the Trigger & Package.

In SQL, a trigger is a special kind of stored procedure that automatically executes or "fires" when
certain events occur in the database, such as after an insert, update, or delete operation on a table.
Triggers are used for enforcing business rules, auditing, validation, and automatic data
modifications. They are particularly useful for maintaining data integrity and consistency.

Example of a Trigger in SQL

Let’s walk through a practical example of a trigger that tracks changes to an employee's salary in a
company. We’ll use a simple scenario with the following requirements:

 Table Structure:
o employees: Contains employee information.
o salary_audit: A table that logs changes to employees' salaries.

Step 1: Create the Tables

 Step 2: Create a Trigger to Track Salary Changes

Next, we create a trigger that will automatically log changes made to the salary field in the
employees table. The trigger will be fired before an update on the salary column, so it will capture the
old value before any changes are applied.

Explanation of the Trigger:

  BEFORE UPDATE OF salary: This specifies that the trigger will fire before an update is made to the
salary column of the employees table.

 FOR EACH ROW: This means the trigger will fire for each row that is updated, not just once for the entire
operation.

 :OLD.salary: Refers to the old value of the salary before the update.

 :NEW.salary: Refers to the new value of the salary after the update.

 salary_audit_seq.NEXTVAL: We assume you have a sequence salary_audit_seq that generates

unique audit_id values for each record in the salary_audit table.

Step 2: Drop the Trigger

If you no longer need the trigger, you can drop it using:

PRACTICAL No: - 07

Objective: Creating the View and explain.

In SQL, a view is a virtual table that is derived from the result of a query. It can represent a
complex query that combines data from one or more tables, or it can simplify repetitive queries by
abstracting them into a single object that can be referenced like a regular table. Views are used for
several purposes, including simplifying complex queries, improving security by restricting access to
certain data, and providing a layer of abstraction.

Scenario:

You are working with an online store database, and you need to generate reports on customer
orders, but you often need to join the customers, orders, and order_items tables. Instead of writing
the same complex query multiple times, you decide to create a view to simplify this.

Step 1: Create Tables for the Example

 Creating the necessary tables to represent a basic e-commerce database with customers, orders,
and order items.
Step 2: Insert Sample Data into the Tables

-- Insert sample customers

INSERT INTO customers (customer_id, first_name, last_name, email)
VALUES (1, 'John', 'Doe', '[email protected]');
INSERT INTO customers (customer_id, first_name, last_name, email)
VALUES (2, 'Jane', 'Smith', '[email protected]');

-- Insert sample orders

INSERT INTO orders (order_id, customer_id, order_date, total_amount)
VALUES (101, 1, TO_DATE('2024-11-01', 'YYYY-MM-DD'), 250.00);
INSERT INTO orders (order_id, customer_id, order_date, total_amount)
VALUES (102, 2, TO_DATE('2024-11-02', 'YYYY-MM-DD'), 150.00);

-- Insert sample order items

INSERT INTO order_items (order_item_id, order_id, product_name, quantity, unit_price)
VALUES (1, 101, 'Laptop', 1, 200.00);
INSERT INTO order_items (order_item_id, order_id, product_name, quantity, unit_price)
VALUES (2, 101, 'Mouse', 2, 25.00);
INSERT INTO order_items (order_item_id, order_id, product_name, quantity, unit_price)
VALUES (3, 102, 'Phone', 1, 150.00);

Step 3: Create a View for Order Details

Create a view that joins the customers, orders, and order_items tables to give us detailed
information about each order, including customer details, order items, and total amounts.
 Explanation:
 CREATE OR REPLACE VIEW order_details: Creates the view named order_details. If a
view with the same name already exists, it will be replaced.
 SELECT statement: The view combines data from the customers, orders, and order_items
tables. It also calculates the total for each item (item_total = quantity * unit_price).
 JOIN operations: We join the three tables (customers, orders, order_items) based on their
relationships (i.e., customer_id and order_id).
Step 4: Query the View

Now that the view is created, you can query it as if it were a regular table. This simplifies the
process of fetching detailed order information.

SELECT * FROM order_details;

 PRACTICAL No: - 08
Objective: Creating Database and Describe the Join Operation in SQL.

In SQL, a join operation is used to combine rows from two or more tables based on a related
column between them. There are different types of joins, such as INNER JOIN, LEFT JOIN, RIGHT
JOIN, and FULL JOIN.

Here's a practical example using two sample tables:

1. Employees table:
employee_id employee_name department_id

1 Shivam 101

2 Shwetank 102

3 Sunny 101

4 Nitin 103

2. Departments table:

department_id department_name

101 HR

102 IT

103 Marketing

Example 1: INNER JOIN

This operation returns rows when there is a match in both tables.

 Result:

employee_id employee_name department_name

1 Shivam HR

2 Shwetank IT

3 Sunny HR

4 Nitin Marketing

Example 2: LEFT JOIN

This operation returns all rows from the left table (Employees), and the matched rows from the
right
table (Departments). If there is no match, NULL values are returned for columns from the right
table

Result:
 employee_id employee_name department_name

1 Shivam HR

2 Shwetank IT

3 Sunny HR

4 Nitin Marketing

(Note: In this example, all employees have matching departments, so the result is similar to the
INNER JOIN. However, if there were employees without a department, the department_name
would show as NULL.)

Example 3: RIGHT JOIN

This operation returns all rows from the right table (Departments), and the matched rows from the
left table (Employees). If there is no match, NULL values are returned for columns from the left table.

Result:

employee_id employee_name department_name

1 Shivam HR
2 Shwetank IT
3 Sunny HR
4 Nitin Marketing

(Note: If there were departments without any employees, the employee_id and employee_name
would show as NULL.)

PRACTICAL No: - 09
 Objective: Creating & implement cursor in SQL.

A cursor in SQL is a database object used to retrieve, manipulate, and navigate through a result set
row by row. Cursors are particularly useful when you need to process each row individually, such as
when performing operations that are difficult or impossible to express in a single SQL query.

Here is a practical example that demonstrates how to create and use a cursor in SQL.

Scenario

we have the following table of Employees:

employee_id employee_name Salary

1 Shivam 5000

2 Shwetank 6000

3 Sunny 7000

4 Nitin 8000

The goal is to use a cursor to update each employee's salary by increasing it by 10% individually.

Steps to Create and Use a Cursor:

1. Declare the cursor – This defines the SQL query that retrieves the rows.
2. Open the cursor – This makes the cursor operational.
3. Fetch the data – This retrieves the rows one by one from the cursor.
4. Process the data – Perform operations like UPDATE or INSERT on each row.
5. Close the cursor – After processing, release the cursor.

SQL Code Example:

 Explanation:

1. Declare the cursor:

The DECLARE employee_cursor CURSOR FOR command defines the cursor and the SQL query
that retrieves the employees' data (employee_id, employee_name, and salary).
2. Open the cursor:
The OPEN command activates the cursor, making it ready to retrieve data.
3. Fetch the data:
The FETCH NEXT FROM employee_cursor INTO ... statement retrieves the next row from the
result set into variables (@EmployeeID, @EmployeeName, and @Salary).
4. Process the data:
Inside the WHILE loop, the UPDATE command increases each employee's salary by 10%. You can
also perform other operations like logging or further computations here.
5. Close the cursor:
After processing all rows, you close the cursor with CLOSE and release the associated resources
using DEALLOCATE.

Key Notes:

 Cursor operations can be resource-intensive, especially for large result sets. It's best to use cursors only
when necessary (e.g., when complex logic requires row-by-row processing).
 Alternative approaches: In many cases, set-based operations (such as UPDATE, INSERT, or SELECT with a
JOIN) can be more efficient than using cursors. Cursors should be considered a last resort when set-based
solutions are not feasible.

Performance Considerations:
 Cursors can cause performance issues, especially on large result sets, because they process rows one at a
time. When possible, always try to use set-based operations (such as an UPDATE statement that processes
all rows at once) instead of row-by-row cursors.
 PRACTICAL No: - 10

Objective:- To implement the basics of PL/SQL.

Introduction – PL/SQL bridges the gap between database technology and procedural
programming languages. It can be thought of as a development tool that extends the
facilities of Oracles SQL database language. Via PL/SQL you can insert, delete, update
and retrieve table data as well as use procedural techniQuestions such as writing loops or
branching to another block of code.

PL/SQL Block structure-

DECLARE
Declarations of memory variables
used later BEGIN
SQL executable statements for manipulating table
data. EXCEPTIONS
SQL and/or PL.SQL code to handle
errors. END;

Displaying user Messages on the screen – Any programming tool requires a method
through which messages can be displayed to the user.

dbms_output is a package that includes a number of procedure and functions that

accumulate information in a buffer so that it can be retrieved later. These functions can
also be used to display message to the user.
put_line: put a piece of information in the buffer followed by a end of line marker. It can
also be used to display message to the user.
Setting the server output on:

SET SERVER OUTPUT ON:

Example: Write the following code in the PL/SQL block to display message
to user DBMS_OUTPUT.PUT_LINE(‘Display user message’)

Conditional control in PL/SQL-

Syntax:
IF <condition> THEN
<Action>
ELSEIF<condi
tion>
<Ac
tion
>
ELS
E
<Ac
tion
 >
EN
DIF
;
The WHILE LOOP:
Syntax:
 WHILE <condition>
LOOP
<Action>
END LOOP;

The FOR LOOP statement:

Syntax:
FOR variable IN [REVERSE] start—end
LOOP
<Action>
END LOOP;

The GOTO statement: The goto statement allows you to change the flow of control within a
PL/SQL Block.
 PRACTICAL No: - 11

In SQL Server, automatic backups and recovery processes are crucial for maintaining database
integrity and ensuring that data can be restored in case of failure. Below are the steps for setting up
automatic backups and recovery.

Setting Up Automatic Backup in SQL Server

Step 1: Configure Backup Plan Using SQL Server Agent

SQL Server Agent is a tool that can be used to automate jobs such as backups. Here's how to set up an
automated backup plan:

1. Open SQL Server Management Studio (SSMS)

o Connect to your SQL Server instance.

2. Enable SQL Server Agent (if not already enabled)

o In SSMS, under "Object Explorer," expand the SQL Server instance.

o Right-click on "SQL Server Agent" and select Start (if it's not running).

3. Create a New Backup Job

o Expand the "SQL Server Agent" node in Object Explorer.

o Right-click on "Jobs" and select New Job.

o In the New Job window, provide a name for the backup job (e.g., "Automated Full Backup").

4. Add a Step for the Backup Command

o Under the Steps tab, click on New to create a step.

o In the New Job Step window:

 Step Name: Give it a descriptive name (e.g., "Full Backup Step").

 Type: Select "Transact-SQL script (T-SQL)".

 Database: Choose the database to back up.

 Command: Enter the T-SQL command for the backup, such as:
 BACKUP DATABASE [YourDatabaseName]
 TO DISK = 'C:\Backups\YourDatabaseName_full.bak'
 WITH FORMAT, MEDIANAME = 'YourBackupMedia', NAME = 'Full Backup of
YourDatabase';
  Click OK to save the step.

5. Set a Schedule for the Backup Job

o Under the Schedules tab, click New to define a backup schedule.

o Set the frequency (e.g., daily, weekly) and the time of the backup.

o Example: Daily at 2:00 AM.

o Click OK to save the schedule.

6. Enable the Job

o Under the Notifications tab (optional), you can configure an email notification if the job succeeds or
fails.

o Click OK to create the backup job.

Now, your SQL Server will automatically run the backup job as per the schedule you've defined.

Step 2: Configure Differential and Transaction Log Backups (Optional)

If you need a more granular backup strategy, you can also automate differential backups and transaction log
backups in a similar way:

 Differential Backup Command:

 BACKUP DATABASE [YourDatabaseName]
 TO DISK = 'C:\Backups\YourDatabaseName_diff.bak'
 WITH DIFFERENTIAL;
 Transaction Log Backup Command:

 BACKUP LOG [YourDatabaseName]

 TO DISK = 'C:\Backups\YourDatabaseName_log.trn';
2. Setting Up Recovery for SQL Server

To perform a recovery of a SQL Server database, you need the backup files and the recovery model
configuration (Full, Simple, or Bulk-logged). The following steps outline how to recover a database from a
backup:

Step 1: Restore a Full Backup

1. Open SQL Server Management Studio (SSMS) and connect to your SQL Server instance.
2. Restore Full Backup:

o In Object Explorer, right-click on Databases and select Restore Database.

o Select the Device option and then choose the backup file.

o If the backup file is located on disk, click Add and locate the .bak file.

o Click OK to restore the database.

Alternatively, you can use T-SQL to restore the database:

RESTORE DATABASE [YourDatabaseName]

FROM DISK = 'C:\Backups\YourDatabaseName_full.bak'
WITH REPLACE;
Step 2: Restore a Differential Backup (if needed)

If you have a differential backup after the full backup, you will need to restore the full backup first, and then
apply the differential backup.

RESTORE DATABASE [YourDatabaseName]

FROM DISK = 'C:\Backups\YourDatabaseName_full.bak';

RESTORE DATABASE [YourDatabaseName]

FROM DISK = 'C:\Backups\YourDatabaseName_diff.bak'
WITH NORECOVERY;

The WITH NORECOVERY option ensures that the database remains in a restoring state, allowing you to apply
transaction log backups afterward.

Step 3: Restore Transaction Log Backups (if needed)

If you have transaction log backups, you can restore them to bring the database to the most recent point in time.

1. Restore the Transaction Log Backup:

2. RESTORE LOG [YourDatabaseName]
3. FROM DISK = 'C:\Backups\YourDatabaseName_log.trn'
4. WITH NORECOVERY;
5. Repeat the Process for subsequent transaction log backups, if needed, until the database is restored to
the desired point in time.

6. Finalize the Restore Process: Once all necessary backups have been restored, you can bring the
database online with:

7. RESTORE DATABASE [YourDatabaseName]

8. WITH RECOVERY;
Step 4: Recovery Model Considerations

Make sure your database’s recovery model is set correctly based on your backup and recovery strategy:

 Full Recovery Model: Supports full, differential, and transaction log backups.
 Simple Recovery Model: Only supports full and differential backups; transaction log backups are not available.

 Bulk-Logged Recovery Model: Similar to the full recovery model, but allows minimal logging for bulk operations.

You can check and set the recovery model using:

-- Check recovery model

SELECT name, recovery_model_desc
FROM sys.databases
WHERE name = 'YourDatabaseName';
-- Change recovery model
ALTER DATABASE [YourDatabaseName]
SET RECOVERY FULL;
3. Automating Backups with SQL Server Maintenance Plans

SQL Server also provides Maintenance Plans that can help automate backup tasks without the need for SQL
Server Agent jobs. You can create a maintenance plan using the Maintenance Plan Wizard in SSMS:

1. Right-click on Management > Maintenance Plans > New Maintenance Plan.

2. Use the Maintenance Plan Wizard to define tasks, including backups.

3. Define the schedule and choose which databases to back up.

4. Save and schedule the plan.

Conclusion

By following these steps, you can set up automatic backups in SQL Server and also recover your database
when needed. It's important to implement a proper backup strategy (including full, differential, and transaction
log backups) to ensure data integrity and quick recovery in case of failure.