10 Marks

1.Explain the Structure of DBMS with neat diagram.

A Database Management System (DBMS) is a software

application that allows users to create, manage, and
access data in a organized and efficient manner. Here's a
breakdown of the DBMS structure along with a diagram for
better understanding:

Components of DBMS:

Query Processor: Acts as an intermediary between the

user's queries and the DBMS. It translates user queries
into instructions that the database understands and
retrieves data accordingly.

Storage Manager: Handles data storage, retrieval, and

organization within the DBMS. It ensures data integrity
and security.

Disk Storage: Physical storage where the actual data

files, data dictionary, and indices are stored.

Diagram:
+--------------------+
| User |
+--------------------+
|
v
+--------------------+
| Application Program |
+--------------------+
|
v
+--------------------+
| Query Processor |
| (Parses & validates queries) |
+--------------------+
|
v
+--------------------+
| Storage Manager |
| (Handles data I/O) |
+--------------------+
|
v
+--------------------+
| Disk Storage |
| (Data Files, |
| Data Dictionary, |
| Indices) |
+--------------------+

2.Outline the Operator Precedence in SQL

In SQL, operator precedence determines the order in

which different operations are performed in an expression.
Here is the hierarchy of SQL operators from highest to
lowest precedence:

1. Unary Operators:

`-`, `+` (Unary minus and plus)

2. Multiplicative Operators:

`*`, `/`

3. Additive Operators:

`+`, `-`

4. Comparison Operators:

`=`, `!=`, `<>`, `>`, `<`, `>=`, `<=`, `!>`, `!<`

5. BETWEEN, IN, LIKE

6. NOT

7. AND

8. OR

Example demonstrating operator precedence in SQL:

Consider the following SQL expression:

```sql
SELECT *
FROM employees
WHERE salary > 50000 OR (salary > 30000 AND
department = 'HR');
```

In this expression:
- The condition inside the parentheses `salary > 30000
AND department = 'HR'` is evaluated first.

3. Classification of DDL and DML Commands

Data Definition Language (DDL)

DDL commands are used to define the structure of the
database, including tables, schemas, indexes, etc. These
commands do not manipulate data but rather define the
structure and organization of data.

Examples of DDL commands.

1. CREATE: Creates a new table, database, index, or

view.

```sql
CREATE TABLE Students (
StudentID int,
Name varchar(255),
Age int
);
```
2. ALTER: Modifies an existing database object, such as a
table.

```sql
ALTER TABLE Students ADD COLUMN Grade
varchar(2);
```
3. DROP: Deletes an existing database object.

```sql
 DROP TABLE Students;
```
4. TRUNCATE: Removes all records from a table, but the
table structure remains.

```sql
TRUNCATE TABLE Students;
```

Data Manipulation Language (DML)

DML commands are used to manipulate the data within

the database. These commands deal with data
manipulation, including inserting, updating, and deleting
data.

Examples of DML commands:

1. INSERT: Adds new records to a table.

```sql
INSERT INTO Students (StudentID, Name, Age)
VALUES (1, 'John Doe', 20);
```
2. UPDATE: Modifies existing records in a table.

```sql
 UPDATE Students SET Age = 21 WHERE StudentID =
1;
```
3. DELETE: Removes existing records from a table.

```sql
DELETE FROM Students WHERE StudentID = 1;
```
4. SELECT: Retrieves data from a table.

```sql
SELECT * FROM Students;
```

4. Types of Data Integrity and Definition of Primary Key

Types of Data Integrity

1. Entity Integrity: Ensures that each row in a table is a

unique entity. This is achieved through the use of primary
keys, which uniquely identify each row in a table.

2. Referential Integrity: Ensures that relationships

between tables remain consistent. This is maintained
using foreign keys, which link the rows of one table to the
rows of another.
3. Domain Integrity: Ensures that all entries in a column
are valid, based on a defined set of rules or constraints.
This can include data types, formats, and ranges.

4. User-Defined Integrity: Enforces specific business

rules not covered by the other three types of integrity.
These rules are defined by the user and can be
implemented through constraints, triggers, and stored
procedures.

Definition of Primary Key

A primary key is a field (or combination of fields) in a

database table that uniquely identifies each record within
the table. It enforces entity integrity by ensuring that each
record can be uniquely identified. Primary keys must
contain unique values and cannot contain NULL values.

5.Explain the followings: a) Creating synonyms b)

Renaming synonyms
c) Removing a synonyms

Creating synonyms: This refers to inventing new words

or expressions that convey the same meaning as an
existing word. This can happen organically over time
through language evolution, or it can be a deliberate act
by writers or language creators.

Renaming synonyms: This doesn't involve creating new

words, but rather giving an existing synonym a different
name. This might be done for various reasons, such as to
make the synonym more clear, concise, or appropriate for
a particular context.

Removing a synonym: This involves taking out a

synonym from a set or list of synonyms. This could be
because the synonym is no longer considered relevant,
accurate, or appropriate.

6. Views in DBMS

In a Database Management System (DBMS), a view acts

as a virtual table that provides a customized view of data
from underlying base tables. It offers a simplified or
focused representation of the data, potentially involving
joins, filters, and other manipulations. Views don't store
data themselves, but rather present a dynamic query of
the base tables.

Benefits of using Views:

Simplified Queries: Views can simplify complex queries
by encapsulating them, making them easier to understand
and reuse.

Data Security: Views can restrict access to sensitive data

by limiting which columns or rows are visible.

Logical Data Independence: Views shield users from

changes to the underlying base tables, as long as the
view's logic remains consistent.

7. Database Triggers

Database triggers are special functions that execute

automatically in response to specific events on a table,
such as insertions, updates, or deletions. They're used to
enforce data integrity, business logic, or automate tasks.

Example:

A trigger can be created to ensure that a customer's credit

limit is never exceeded whenever a new order is placed.
The trigger would fire on insert events in the 'Orders' table,
verify the customer's credit limit, and potentially roll back
the order if the limit is reached.
8. Types of Keys in DBMS.

Keys are columns (or sets of columns) within a database

table that uniquely identify rows. Here are the common
types of keys:

Primary Key: A table can only have one primary key,

which is a column (or a combination of columns) that
uniquely identifies each row in the table. No two rows can
have the same value for the primary key.

Example: In a 'Customers' table, the 'Customer ID' column

could be the primary key, as it uniquely identifies each
customer.

Candidate Key: Any set of columns that can uniquely

identify rows in a table is a candidate key. A table can
have multiple candidate keys, but only one is chosen as
the primary key.

Example: In a 'Products' table, both 'Product ID' and a

combination of 'Product Name' and 'Brand' could be
candidate keys.
 Foreign Key: A foreign key is a column (or set of
columns) in one table that references the primary key of
another table. It establishes a link between related tables,
ensuring data integrity and consistency.

Example: An 'Orders' table might have a 'CustomerID'

foreign key that references the primary key ('Customer ID')
in the 'Customers' table.

9. Relational Algebra Operations

Relational algebra is a theoretical framework for

manipulating relations (tables) in a relational database. It
provides a set of operators to perform various tasks on
relational data. Here are some fundamental operations:

Selection (σ): Selects rows from a table based on a

specific condition.

Projection (π): Creates a new table by selecting specific

columns from an existing table.

Union (U): Combines the rows of two compatible tables,

eliminating duplicates.
 Set Difference (-): Results in rows present in one table
but not in another.

Set Intersection (∩): Includes rows that are common to

both input tables.

Rename (ρ): Assigns new names to tables or columns.

Cartesian Product (X): Creates a new table by

combining all rows from two tables.

10. Data Types in SQL Language

Data types in SQL define the kind of value that can be

stored in a column of a table. Each column in a table must
be assigned a data type, which dictates the nature of the
data that the column can hold. Here are the primary
categories of data types in SQL:

Numeric Data Types

1. INT, INTEGER: Used for whole numbers.

Example: `INT`.

- `SMALLINT`: Smaller range of integers.

 - `BIGINT`: Larger range of integers.

2. FLOAT, REAL, DOUBLE PRECISION: Used for

floating-point numbers.

- `FLOAT`: Floating point number with precision.

- `REAL`: Single precision floating point number.
- `DOUBLE PRECISION`: Double precision floating point
number.

3. DECIMAL, NUMERIC: Used for fixed-point numbers,

where precision and scale are defined.

- `DECIMAL(p, s)`: `p` is precision (total number of

digits), and `s` is scale (number of digits to the right of the
decimal point).

Character Data Types

1. CHAR, CHARACTER: Fixed-length character data.

- `CHAR(n)`: Fixed-length character data of length `n`.

2. VARCHAR, CHARACTER VARYING: Variable-length

character data.
 - `VARCHAR(n)`: Variable-length character data with a
maximum length of `n`.

3. TEXT: Variable-length character data with an unlimited

length.

Date and Time Data Types

1. DATE: Stores date values (year, month, day).

2. TIME: Stores time values (hour, minute, second).
3. TIMESTAMP: Stores both date and time values.
4. INTERVAL: Represents a period of time.

Binary Data Types

1. BINARY: Fixed-length binary data.

- `BINARY(n)`: Fixed-length binary data of length `n`.

2. VARBINARY: Variable-length binary data.

- `VARBINARY(n)`: Variable-length binary data with a

maximum length of `n`.

3. BLOB (Binary Large Object): Used for large binary

data.
Boolean Data Type

1. BOOLEAN: Stores true or false values.

11. Client-Server Architecture in Detail

The client-server architecture is a network design

framework that divides tasks or workloads between
providers of a resource or service, called servers, and
requesters of a service, called clients. This architecture is
foundational to network computing and is used in various
applications, from web services to database management.

Components of Client-Server Architecture

1. Client:

- The client is the requesting machine or software.

- It interacts with the user through a user interface.
- Sends requests to the server for processing.

2. Server:

- The server is the providing machine or software.

- It receives requests from the client, processes them,
and sends back the required responses.
 - Can handle multiple clients simultaneously.

Types of Servers

1. Web Server: Serves web pages to clients (browsers).

2. Database Server: Provides database services to client

applications.

3. File Server: Manages and provides access to files.

4. Application Server: Hosts applications and provides

business logic.

Communication Protocols

1. HTTP/HTTPS: Used for web communication.

2. FTP: Used for file transfers.
3. SMTP/IMAP/POP3: Used for email services.
4. SQL: Used for database queries.

Benefits of Client-Server Architecture

1. Centralized Resources: Servers provide centralized

resources, making management and security easier.
2. Scalability: Can handle increasing loads by adding more
servers or enhancing existing ones.
3.Maintenance: Easier to maintain since updates and
patches can be applied to servers without affecting clients
directly.
4. Specialization: Servers can be specialized for specific
tasks, improving efficiency and performance.

14. PL/SQL Program to Calculate the Factorial Value of a

Given Number

Here's a PL/SQL program to calculate the factorial of a

given number:

```
DECLARE
num NUMBER;
factorial NUMBER := 1;
BEGIN
num := &input_num; -- Accept input from the user

IF num < 0 THEN

DBMS_OUTPUT.PUT_LINE('Factorial is not defined
for negative numbers');
ELSE
FOR i IN REVERSE 1..num LOOP
factorial := factorial * i;
END LOOP;
 DBMS_OUTPUT.PUT_LINE('The factorial of ' || num ||
' is ' || factorial);
END IF;
END;
/
```

15. Union and Intersection Queries

Assume the tables are structured as follows:

```sql
CREATE TABLE Customer (
Cno INT,
Cname VARCHAR(50),
Ccity VARCHAR(50)
);

CREATE TABLE Account (

A_no INT,
A_Type VARCHAR(50),
Balance DECIMAL(10, 2),
CCity VARCHAR(50)
);
```

Union Query
The `UNION` operation combines the result sets of two or
more `SELECT` queries:

```sql
SELECT Ccity FROM Customer
UNION
SELECT CCity FROM Account;
```

Intersection Query

The `INTERSECT` operation returns the common records

from two `SELECT` queries:

```sql
SELECT Ccity FROM Customer
INTERSECT
SELECT CCity FROM Account;
```
16.Explain about the operators in SQL.

SQL operators are used to perform operations on data

within SQL queries. They help in filtering, sorting, and
manipulating data. Here’s a brief overview of different
types of operators in SQL:
1. Arithmetic Operators: Perform basic mathematical
operations.

`+` (Addition): Adds two values.

`-` (Subtraction): Subtracts one value from another.
`*` (Multiplication): Multiplies two values.
`/` (Division): Divides one value by another.
`%` (Modulus): Returns the remainder of a division.

2. Comparison Operators: Compare two values and

return a boolean result.

`=` (Equal): Checks if two values are equal.

`!=` or `<>` (Not Equal): Checks if two values are not
equal.
`>` (Greater Than): Checks if one value is greater than
another.
`<` (Less Than): Checks if one value is less than
another.
`>=` (Greater Than or Equal To): Checks if one value is
greater than or equal to another.
`<=` (Less Than or Equal To): Checks if one value is less
than or equal to another.

3. Logical Operators: Combine multiple conditions.

`AND`: Returns true if all conditions are true.

 `OR`: Returns true if at least one condition is true.
`NOT`: Reverses the boolean value of a condition.

4. BETWEEN Operator: Checks if a value is within a

range.

`BETWEEN` ... `AND`: Checks if a value falls within a

specified range.

5. IN Operator: Checks if a value matches any value in a

list.

`IN`: Checks if a value exists within a specified set of

values.

6. LIKE Operator: Searches for a specified pattern in a

column.

`LIKE`: Used with wildcard characters (`%` for any

sequence of characters and `_` for a single character).

7. IS NULL / IS NOT NULL Operators: Checks for null

values.

`IS NULL`: Checks if a value is null.

`IS NOT NULL`: Checks if a value is not null.
17. Built-in Functions in SQL

SQL provides various built-in functions to perform

operations on data. These functions can be categorized
into different types:

1. Aggregate Functions: Perform calculations on a set of

values and return a single value.

`COUNT()`: Returns the number of rows.

`SUM()`: Returns the sum of a numeric column.

`AVG()`: Returns the average value of a numeric

column.

`MIN()`: Returns the smallest value.

`MAX()`: Returns the largest value.

2. String Functions: Operate on string values.

CONCAT() : Concatenates two or more strings.

SUBSTRING() : Extracts a substring from a string.

LENGTH() : Returns the length of a string.

3. Date Functions: Work with date and time values.

NOW() : Returns the current date and time.

DATEADD():Adds a specified time interval to a date.

DATEDIFF(): Returns the difference between two dates.

4. Mathematical Functions: Perform mathematical

operations.

ROUND(): Rounds a number to a specified number of

decimal places.

CEIL(): Rounds a number up to the nearest integer.

FLOOR(): Rounds a number down to the nearest

integer.

5. Conversion Functions: Convert data from one type to

another.
 CAST(): Converts an expression from one data type to
another.

-CONVERT(): Converts a value to a specified data type.

18.Explain about the nested query and complex query with

example.

Nested Queries:

A nested query, also known as a subquery, is a select

statement embedded within another select statement.

The inner query's result set is used as part of the WHERE

clause or JOIN condition in the outer query.

Complex Queries:

Complex queries combine multiple SQL clauses (FROM,

WHERE, JOIN, GROUP BY, HAVING, ORDER BY) to
retrieve and manipulate data based on sophisticated
criteria.

They often involve nested queries, aggregations

(functions like SUM, AVG, COUNT), and multi-table joins.
21.Elaborate iterative statements in PL/SQL.

Iterative statements, also known as loops, are a

fundamental construct in PL/SQL that allow you to execute
a block of code repeatedly until a certain condition is met.
PL/SQL offers three main types of loops:

FOR Loop: This loop is ideal for iterating a fixed number

of times based on a counter variable. It's concise and
efficient for predetermined iterations.

WHILE Loop: This loop continues executing the code

block as long as a specified condition remains true. It's
useful for situations where the number of iterations is
unknown beforehand.

LOOP Statement: This loop provides more flexibility as it

doesn't rely on a predetermined condition or counter. It
continues executing until an explicit termination statement
(EXIT) is encountered within the loop body.