Experiment No.

1
Aim: Study of Entity- Relationship diagram.
Theory:
Entity relationship model defines the conceptual view of database. It works around real world
entity and association among them. At view level, ER model is considered well for designing
databases.

Entity

A real-world thing either animate or inanimate that can be easily identifiable and distinguishable.
For example, in a school database, student, teachers, class and course offered can be considered
as entities. All entities have some attributes or properties that give them their identity.

An entity set is a collection of similar types of entities. Entity set may contain entities with
attribute sharing similar values. For example, Students set may contain all the student of a
school; likewise Teachers set may contain all the teachers of school from all faculties. Entities
sets need not to be disjoint.

Attributes

Entities are represented by means of their properties, called attributes. All attributes have values.
For example, a student entity may have name, class, age as attributes.

There exist a domain or range of values that can be assigned to attributes. For example, a
student's name cannot be a numeric value. It has to be alphabetic. A student's age cannot be
negative, etc.

Types of attributes:

Simple attribute:

Simple attributes are atomic values, which cannot be divided further. For example, student's
phone-number is an atomic value of 10 digits.

Composite attribute:

Composite attributes are made of more than one simple attribute. For example, a student's
complete name may have first_name and last_name.

Derived attribute:

Derived attributes are attributes, which do not exist physical in the database, but there values are
derived from other attributes presented in the database. For example, average_salary in a

1
department should be saved in database instead it can be derived. For another example, age can
be derived from data_of_birth.

Single-valued attribute:

Single valued attributes contain on single value. For example: Social_Security_Number.

Multi-value attribute:

Multi-value attribute may contain more than one values. For example, a person can have more
than one phone numbers, email_addresses etc.

These attribute types can come together in a way like:

simple single-valued attributes

simple multi-valued attributes

composite single-valued attributes

composite multi-valued attributes

Entity-set and Keys

Key is an attribute or collection of attributes that uniquely identifies an entity among entity set.

For example, roll_number of a student makes her/him identifiable among students.

Super Key: Set of attributes oneormore that collectively identifies an entity in an entity
set.

Candidate Key: Minimal super key is called candidate key that is, supers keys for which
no proper subset are a superkey. An entity set may have more than one candidate key.

Primary Key: This is one of the candidate key chosen by the database designer to
uniquely identify the entity set.

Relationship

The association among entities is called relationship. For example, employee entity has relation
works_at with department. Another example is for student who enrolls in some course. Here,
Works_at and Enrolls are called relationship.

Relationship Set:

2
Relationship of similar type is called relationship set. Like entities, a relationship too can have
attributes. These attributes are called descriptive attributes.

Degree of relationship

The number of participating entities in an relationship defines the degree of the relationship.

Binary = degree 2

Ternary = degree 3

n-ary = degree

Mapping Cardinalities:

Cardinality defines the number of entities in one entity set which can be associated to the
number of entities of other set via relationship set.

One-to-one: one entity from entity set A can be associated with at most one entity of
entity set B and vice versa.

[Image: One-to-one relation]

One-to-many: One entity from entity set A can be associated with more than one entities
of entity set B but from entity set B one entity can be associated with at most one entity.

3
[Image: One-to-many relation]

Many-to-one: More than one entities from entity set A can be associated with at most
one entity of entity set B but one entity from entity set B can be associated with more
than one entity from entity set A.

[Image: Many-to-one relation]

Many-to-many: one entity from A can be associated with more than one entity from B
and vice versa.

[Image: Many-to-many relation]

4
Every object like entity, attributes of an entity, relationship set, and attributes of relationship set
can be represented by tools of ER diagram.

Entity

Entities are represented by means of rectangles. Rectangles are named with the entity set they
represent.

[Image: Entities in a school database]

Attributes

Attributes are properties of entities. Attributes are represented by means of eclipses. Every
eclipse represents one attribute and is directly connected to its entity rectangle.

[Image: Simple Attributes]

If the attributes are composite, they are further divided in a tree like structure. Every node is
then connected to its attribute. That is composite attributes are represented by eclipses that are
connected with an eclipse.

[Image: Composite Attributes]

Multivalued attributes are depicted by double eclipse.

5
[Image: Multivalued Attributes]

Derived attributes are depicted by dashed eclipse.

[Image: Derived Attributes]

Relationship

Relationships are represented by diamond shaped box. Name of the relationship is written in the
diamond-box. All entities rectangles, participating in relationship, are connected to it by a line.

Binary relationship and cardinality

A relationship where two entities are participating, is called a binary relationship. Cardinality is
the number of instance of an entity from a relation that can be associated with the relation.

One-to-one

When only one instance of entity is associated with the relationship, it is marked as '1'. This
image below reflects that only 1 instance of each entity should be associated with the
relationship. It depicts one-to-one relationship

6
[Image: One-to-one]

One-to-many

When more than one instance of entity is associated with the relationship, it is marked as 'N'.
This image below reflects that only 1 instance of entity on the left and more than one instance of
entity on the right can be associated with the relationship. It depicts one-to-many relationship

[Image: One-to-many]

Many-to-one

When more than one instance of entity is associated with the relationship, it is marked as 'N'.
This image below reflects that more than one instance of entity on the left and only one instance
of entity on the right can be associated with the relationship. It depicts many-to-one relationship

[Image: Many-to-one]

Many-to-many

This image below reflects that more than one instance of entity on the left and more than one
instance of entity on the right can be associated with the relationship. It depicts many-to-many
relationship

7
[Image: Many-to-many]

Participation Constraints

Total Participation: Each entity in the entity is involved in the relationship. Total
participation is represented by double lines.

Partial participation: Not all entities are involved in the relation ship. Partial
participation is represented by single line.

[Image: Participation Constraints]

Conclusion:

Thus, in this experiment we have studied ER diagram representations.

8
 Experiment No.2
Aim: Basic SQL-write simple queries in SQL on the schema created for a specific
application.

Theory:
Data Manipulation Language
SQL is equipped with data manipulation language. DML modifies the database instance by
inserting, updating and deleting its data. DML is responsible for all data modification in
databases. SQL contains the following set of command in DML section:

SELECT/FROM/WHERE

INSERT INTO/VALUES

UPDATE/SET/WHERE

DELETE FROM/WHERE

These basic constructs allows database programmers and users to enter data and information into
the database and retrieve efficiently using a number of filter options.

SELECT/FROM/WHERE

SELECT

This is one of the fundamental query command of SQL. It is similar to projection

operation of relational algebra. It selects the attributes based on the condition described
by WHERE clause.

FROM

This clause takes a relation name as an argument from which attributes are to be
selected/projected. In case more than one relation names are given this clause
corresponds to cartesian product.

WHERE

This clause defines predicate or conditions which must match in order to qualify the
attributes to be projected.

For example:

9
 Select author_name
From book_author
Where age > 50;

This command will project names of authors from book_author relation whose age is
greater than 50.

INSERT INTO/VALUES

This command is used for inserting values into rows of table relation.
Syntax is

INSERT INTO table (column1 [, column2, column3 ... ]) VALUES (value1 [, value2, value3 ... ])

Or

INSERT INTO table VALUES (value1, [value2, ... ])

For Example:

INSERT INTO tutorialspoint (Author, Subject) VALUES ("anonymous", "computers");

UPDATE/SET/WHERE

This command is used for updating or modifying values of columns of table relation.
Syntax is

UPDATE table_name SET column_name = value [, column_name = value ...] [WHERE

condition]

For example:

UPDATE tutorialspoint SET Author="webmaster" WHERE Author="anonymous";

DELETE/FROM/WHERE

This command is used for removing one or more rows from table relation.
Syntax is

DELETE FROM table_name [WHERE condition];

For example:

10
DELETE FROM tutorialspoints

WHERE Author="unknown";

Conclusion:
Thus the different simple DML commands used for inserting, updating, deleting, and selecting
are performed successfully and executed.

11
 Experiment No: 3

AIM: To execute nested queries.

Theory:
NESTED QUERIES:
A subquery is a query within a query. Nested Query can have more than one level of nesting in
one single query. A SQL nested query is a SELECT query that is nested inside a SELECT,
UPDATE, INSERT, or DELETE SQL query.

PROCEDURE
STEP 1: Start
STEP 2: Create two different tables with its essential attributes.
STEP 3: Insert attribute values into the table.
STEP 4: Create the Nested query from the above created table.
STEP 5: Execute Command and extract information from the tables.
STEP 6: Stop

SQL COMMANDS

1. COMMAND NAME: SELECT

COMMAND DESCRIPTION: SELECTcommand is used to select records from the table.

2. COMMAND NAME: WHERE

COMMAND DESCRIPTION: WHEREcommand is used to identify particular elements.

3. COMMAND NAME: HAVING

COMMAND DESCRIPTION: HAVINGcommand is used to identify particular elements.

4. COMMAND NAME: MIN (SAL)

COMMAND DESCRIPTION: MIN (SAL)command is used to find minimum salary.

Table -1
SYNTAX FOR CREATING A TABLE:
SQL: CREATE <OBJ.TYPE> <OBJ.NAME> (COLUMN NAME.1 <DATATYPE>
(SIZE), COLUMN NAME.1 <DATATYPE> (SIZE) );
SQL> CREATE TABLE EMP2(EMPNO NUMBER(5),
ENAME VARCHAR2(20),
JOB VARCHAR2(20),
SAL NUMBER(6),
MGRNO NUMBER(4),
DEPTNO NUMBER(3));
SYNTAX FOR INSERT RECORDS IN TO A TABLE:
SQL :> INSERT INTO <TABLE NAME> VALUES< VAL1, VAL2,..);
INSERTION
SQL> INSERT INTO EMP2 VALUES(1001,'MAHESH','PROGRAMMER',15000,1560,200);

12
1 ROW CREATED.
SQL> INSERT INTO EMP2 VALUES(1002,'MANOJ','TESTER',12000,1560,200);
1 ROW CREATED.
SQL> INSERT INTO EMP2 VALUES(1003,'KARTHIK','PROGRAMMER',13000,1400,201);
1 ROW CREATED.
SQL> INSERT INTO EMP2 VALUES(1004,'NARESH','CLERK',1400,1400,201);
1 ROW CREATED.
SQL> INSERT INTO EMP2 VALUES(1005,'MANI','TESTER',13000,1400,200);
1 ROW CREATED.
SQL> INSERT INTO EMP2 VALUES(1006,'VIKI','DESIGNER',12500,1560,201);
1 ROW CREATED.
SQL> INSERT INTO EMP2 VALUES(1007,'MOHAN','DESIGNER',14000,1560,201);
1 ROW CREATED.
SQL> INSERT INTO EMP2 VALUES(1008,'NAVEEN','CREATION',20000,1400,201);
1 ROW CREATED.
SQL> INSERT INTO EMP2 VALUES(1009,'PRASAD','DIR',20000,1560,202);
1 ROW CREATED.
SQL> INSERT INTO EMP2 VALUES(1010,'AGNESH','DIR',15000,1400,200);
1 ROW CREATED.
SYNTAX FOR SELECT RECORDS FROM THE TABLE:
SQL> SELECT * FROM <TABLE NAME>;
SQL> SELECT *FROM EMP2;
EMPNO ENAME JOB SAL MGRNO DPTNO
---------- ---------- ---------- ---------- ---------- ----------
1001 MAHESH PROGRAMMER 15000 1560 200
1002 MANOJ TESTER 12000 1560 200
1003 KARTHIK PROGRAMMER 13000 1400 201
1004 NARESH CLERK 1400 1400 201
1005 MANI TESTER 13000 1400 200
1006 VIKI DESIGNER 12500 1560 201
1007 MOHAN DESIGNER 14000 1560 201
1008 NAVEEN CREATION 20000 1400 201
1009 PRASAD DIR 20000 1560 202
1010 AGNESH DIR 15000 1400 200
TABLE- 2
SYNTAX FOR CREATING A TABLE:
SQL: CREATE <OBJ.TYPE> <OBJ.NAME> (COLUMN NAME.1 <DATATYPE>
(SIZE), COLUMN NAME.1 <DATATYPE> (SIZE) );
SQL> CREATE TABLE DEPT2(DEPTNO NUMBER(3),
DEPTNAME VARCHAR2(10),
LOCATION VARCHAR2(15));
Table created.
SYNTAX FOR INSERT RECORDS IN TO A TABLE:
SQL :> INSERT INTO <TABLE NAME> VALUES< VAL1, VAL2,..);
INSERTION
SQL> INSERT INTO DEPT2 VALUES(107,'DEVELOP','ADYAR');

13
1 ROW CREATED.
SQL> INSERT INTO DEPT2 VALUES(201,'DEBUG','UK');
1 ROW CREATED.
SQL> INSERT INTO DEPT2 VALUES(200,'TEST','US');
SQL> INSERT INTO DEPT2 VALUES(201,'TEST','USSR');
1 ROW CREATED.
SQL> INSERT INTO DEPT2 VALUES(108,'DEBUG','ADYAR');
1 ROW CREATED.
SQL> INSERT INTO DEPT2 VALUES(109,'BUILD','POTHERI');
1 ROW CREATED.
SYNTAX FOR SELECT RECORDS FROM THE TABLE:
SQL> SELECT * FROM <TABLE NAME>;
SQL> SELECT *FROM DEPT2;
DEPTNO DEPTNAME LOCATION
---------- ---------- ---------------
107 DEVELOP ADYAR
201 DEBUG UK
200 TEST US
201 TEST USSR
108 DEBUG ADYAR
109 BUILD POTHERI
6 rows selected.
GENERAL SYNTAX FOR NESTED QUERY:
SELECT "COLUMN_NAME1"
FROM "TABLE_NAME1"
WHERE "COLUMN_NAME2" [COMPARISON OPERATOR]
(SELECT "COLUMN_NAME3"
FROM "TABLE_NAME2"
WHERE [CONDITION])
SYNTAX NESTED QUERY STATEMENT:
SQL> SELECT <COLUMN_NAME> FROM FRORM <TABLE _1> WHERE
<COLUMN_NAME> <RELATIONAL _OPERATION> VALUE
(SELECT (AGGRECATE FUNCTION) FROM <TABLE_1> WHERE <COLUMN
NAME> = VALUE
(SELECT <COLUMN_NAME> FROM <TABLE_2> WHERE <COLUMN_NAME=
VALUE));
NESTED QUERY STATEMENT:
SQL> SELECT ENAME FROM EMP2 WHERE SAL>
(SELECT MIN(SAL) FROM EMP2 WHERE DPTNO=
(SELECT DEPTNO FROM DEPT2 WHERE LOCATION='UK'));
Nested Query Output:
ENAME
MAHESH
MANOJ
KARTHIK
MANI

14
VIKI
MOHAN
NAVEEN
PRASAD
AGNESH

Conclusion:
Thus the nested queries are executed and verified in DBMS.

15
 Experiment No. 4
Aim: To practice and implement data definition language commands and constraints.

Theory:
DDL COMMAND It is used to communicate with database. DDL is used to: o Create an object o
Alter the structure of an object o To drop the object created.

The commands used are: Create, Alter, Drop, Truncate

INTEGRITY CONSTRAINT An integrity constraint is a mechanism used by oracle to prevent

invalid data entry into the table. It has enforcing the rules for the columns in a table. The types of
the integrity constraints are: a) Domain Integrity b) Entity Integrity c) Referential Integrity

Domain Integrity: This constraint sets a range and any violations that take place will prevent the
user from performing the manipulation that caused the breach. It includes: Not Null constraint:
While creating tables, by default the rows can have null value .the enforcement of not null
constraint in a table ensure that the table contains values. Principle of null values:

Setting null value is appropriate when the actual value is unknown, or when a value
would not be meaningful
A null value is not equivalent to a value of zero.
A null value will always evaluate to null in any expression.
When a column name is defined as not null, that column becomes a mandatory i.e., the
user has to enter data into it.
Not null Integrity constraint cannot be defined using the alter table command when the
table contain rows.

Check Constraint: Check constraint can be defined to allow only a particular range of values
when the manipulation violates this constraint, the record will be rejected. Check condition
cannot contain sub queries.

Entity Integrity: Maintains uniqueness in a record. An entity represents a table and each row of a
table represents an instance of that entity. To identify each row in a table uniquely we need to use
this constraint. There are 2 entity constraints:

Unique key constraint It is used to ensure that information in the column for each record
is unique, as with telephone or drivers license numbers. It prevents the duplication of
value with rows of a specified column in a set of column. A column defined with the
constraint can allow null value. If unique key constraint is defined in more than one
column i.e., combination of column cannot be specified. Maximum combination of
columns that a composite unique key can contain is 16.

16
 Primary Key Constraint A primary key avoids duplication of rows and does not allow null
values. It can be defined on one or more columns in a table and is used to uniquely
identify each row in a table. These values should never be changed and should never be
null. A table should have only one primary key. If a primary key constraint is assigned to
more than one column or combination of column is said to be composite primary key,
which can contain 16 columns.

Referential Integrity: It enforces relationship between tables. To establish parent-child

relationship between 2 tables having a common column definition, we make use of this
constraint. To implement this, we should define the column in the parent table as primary key
and same column in the child table as foreign key referring to the corresponding parent entry.

Foreign key: A column or combination of column included in the definition of referential

integrity, which would refer to a referenced key.

Referenced key: It is a unique or primary key upon which is defined on a column belonging to
the parent table.

Conclusion:

Thus the data definition language commands was performed and implemented successfully.

17
 Experiment No. 5
Aim: Convert the created database into 1NF, 2NF, 3NF and BCNF.

Theory:

Functional Dependency

Functional dependency FD is set of constraints between two attributes in a relation. Functional

dependency says that if two tuples have same values for attributes A1, A2,..., An then those two
tuples must have to have same values for attributes B1, B2, ..., Bn.

Functional dependency is represented by arrow sign , that is XY, where X functionally

determines Y. The left hand side attributes determines the values of attributes at right hand side.

Armstrong's Axioms

If F is set of functional dependencies then the closure of F, denoted as F+, is the set of all
functional dependencies logically implied by F. Armstrong's Axioms are set of rules, when
applied repeatedly generates closure of functional dependencies.

Reflexive rule: If alpha is a set of attributes and beta is_subset_of alpha, then alpha holds
beta.

Augmentation rule: if a b holds and y is attribute set, then ay by also holds. That
is adding attributes in dependencies, does not change the basic dependencies.

Transitivity rule: Same as transitive rule in algebra, if a b holds and b c holds then
a c also hold. a b is called as a functionally determines b.

Trivial Functional Dependency

Trivial: If an FD X Y holds where Y subset of X, then it is called a trivial FD. Trivial

FDs are always hold.

Non-trivial: If an FD X Y holds where Y is not subset of X, then it is called non-

trivial FD.

Completely non-trivial: If an FD X Y holds where x intersect Y = , is said to be

completely non-trivial FD.

Normalization

If a database design is not perfect it may contain anomalies, which are like a bad dream for
database itself. Managing a database with anomalies is next to impossible.

18
 Update anomalies: if data items are scattered and are not linked to each other properly,
then there may be instances when we try to update one data item that has copies of it
scattered at several places, few instances of it get updated properly while few are left with
there old values. This leaves database in an inconsistent state.

Deletion anomalies: we tried to delete a record, but parts of it left undeleted because of
unawareness, the data is also saved somewhere else.

Insert anomalies: we tried to insert data in a record that does not exist at all.

Normalization is a method to remove all these anomalies and bring database to consistent state
and free from any kinds of anomalies.

First Normal Form:

This is defined in the definition of relations tables itself. This rule defines that all the attributes in
a relation must have atomic domains. Values in atomic domain are indivisible units.

[Image: Unorganized relation]

We re-arrange the relation table as below, to convert it to First Normal Form

[Image: Relation in 1NF]

Each attribute must contain only single value from its pre-defined domain.

Second Normal Form:

Before we learn about second normal form, we need to understand the following:

19
 Prime attribute: an attribute, which is part of prime-key, is prime attribute.

Non-prime attribute: an attribute, which is not a part of prime-key, is said to be a non-

prime attribute.

Second normal form says, that every non-prime attribute should be fully functionally dependent
on prime key attribute. That is, if X A holds, then there should not be any proper subset Y of
X, for that Y A also holds.

[Image: Relation not in 2NF]

We see here in Student_Project relation that the prime key attributes are Stu_ID and Proj_ID.
According to the rule, non-key attributes, i.e. Stu_Name and Proj_Name must be dependent upon
both and not on any of the prime key attribute individually. But we find that Stu_Name can be
identified by Stu_ID and Proj_Name can be identified by Proj_ID independently. This is called
partial dependency, which is not allowed in Second Normal Form.

[Image: Relation in 2NF]

We broke the relation in two as depicted in the above picture. So there exists no partial
dependency.

Third Normal Form:

For a relation to be in Third Normal Form, it must be in Second Normal form and the following
must satisfy:

No non-prime attribute is transitively dependent on prime key attribute

For any non-trivial functional dependency, X A, then either

20
 X is a superkey or,

A is prime attribute.

[Image: Relation not in 3NF]

We find that in above depicted Student_detail relation, Stu_ID is key and only prime key
attribute. We find that City can be identified by Stu_ID as well as Zip itself. Neither Zip is a
superkey nor City is a prime attribute. Additionally, Stu_ID Zip City, so there
exists transitive dependency.

[Image: Relation in 3NF]

We broke the relation as above depicted two relations to bring it into 3NF.

Boyce-Codd Normal Form:

BCNF is an extension of Third Normal Form in strict way. BCNF states that

For any non-trivial functional dependency, X A, then X must be a super-key.

In the above depicted picture, Stu_ID is super-key in Student_Detail relation and Zip is super-
key in ZipCodes relation. So,

Stu_ID Stu_Name, Zip

And

Zip City

Confirms, that both relations are in BCNF.

Conclusion:
21
Thus we have studied different normal forms and conversion from one form to another.

Experiment No. 6
Aim: Write a Java program for database (created in previous assignments) connectivity
using JDBC.

Theory:
JDBC is a Java API that is used to connect and execute query to the database. JDBC API uses
jdbc drivers to connect to the database.

JDBC Driver is a software component that enables java application to interact with the
database. There are 4 types of JDBC drivers:
1. JDBC-ODBC bridge driver

2. Native-API driver (partially java driver)

3. Network Protocol driver (fully java driver)

4. Thin driver (fully java driver)

1) JDBC-ODBC bridge driver

22
The JDBC-ODBC bridge driver uses ODBC driver to connect to the database. The JDBC-ODBC
bridge driver converts JDBC method calls into the ODBC function calls. This is now
discouraged because of thin driver.

Advantages:

easy to use.

can be easily connected to any database.

Disadvantages:

Performance degraded because JDBC method call is converted into the ODBC function
calls.

The ODBC driver needs to be installed on the client machine.

2) Native-API driver

The Native API driver uses the client-side libraries of the database. The driver converts JDBC
method calls into native calls of the database API. It is not written entirely in java.

Advantage:

Performance upgraded than JDBC-ODBC bridge driver.

Disadvantage:

23
 The Native driver needs to be installed on the each client machine.

The Vendor client library needs to be installed on client machine.

3) Network Protocol driver

The Network Protocol driver uses middleware (application server) that converts JDBC calls
directly or indirectly into the vendor-specific database protocol. It is fully written in java.

Advantage:

No client side library is required because of application server that can perform many
tasks like auditing, load balancing, logging etc.

Disadvantages:

Network support is required on client machine.

Requires database-specific coding to be done in the middle tier.

Maintenance of Network Protocol driver becomes costly because it requires database-

specific coding to be done in the middle tier.

4) Thin driver

The thin driver converts JDBC calls directly into the vendor-specific database protocol. That is
why it is known as thin driver. It is fully written in Java language.

24
Advantage:

Better performance than all other drivers.

No software is required at client side or server side.

Disadvantage:

Drivers depends on the Database.

There are 5 steps to connect any java application with the database in java using JDBC. They are
as follows:

Register the driver class

Creating connection

Creating statement

Executing queries

Closing connection

1) Register the driver class

The forName() method of Class class is used to register the driver class. This method is used
to dynamically load the driver class.

Syntax of forName() method

public static void forName(String className)throws ClassNotFoundException
Example to register the OracleDriver class

Class.forName("oracle.jdbc.driver.OracleDriver");

25
2) Create the connection object

The getConnection() method of DriverManager class is used to establish connection with the
database.

Syntax of getConnection() method

1) public static Connection getConnection(String url)throws SQLException
2) public static Connection getConnection(String url,String name,String password)
throws SQLException
Example to establish connection with the Oracle database

Connection con=DriverManager.getConnection(
"jdbc:mysql://localhost:3306/dbname","root","root");

3) Create the Statement object

The createStatement() method of Connection interface is used to create statement. The
object of statement is responsible to execute queries with the database.

Syntax of createStatement() method

public Statement createStatement()throws SQLException
Example to create the statement object

Statement stmt=con.createStatement();
4) Execute the query
The executeQuery() method of Statement interface is used to execute queries to the database.
This method returns the object of ResultSet that can be used to get all the records of a table.

Syntax of executeQuery() method

public ResultSet executeQuery(String sql)throws SQLException
Example to execute query

ResultSet rs=stmt.executeQuery("select * from emp");

while(rs.next()){
System.out.println(rs.getInt(1)+" "+rs.getString(2));
}

Conclusion:

Hence JDBC is implemented.

26
 Experiment No. 7
Aim: Write a program to implement B+ tree index (n=3 or n=5) on the database
previously created.

Theory:

B+ Tree
B<sup+< sup=""> tree is multi-level index format, which is balanced binary search trees. As
mentioned earlier single level index records becomes large as the database size grows, which
also degrades performance.</sup+<>

All leaf nodes of B+ tree denote actual data pointers. B+ tree ensures that all leaf nodes remain at
the same height, thus balanced. Additionally, all leaf nodes are linked using link list, which
makes B+ tree to support random access as well as sequential access.

Structure of B+ tree

Every leaf node is at equal distance from the root node. A B+ tree is of order n where n is fixed
for every B+ tree.

[Image: B+ tree]

Internal nodes:

Internal nonleaf nodes contains at least n/2 pointers, except the root node.
At most, internal nodes contain n pointers.

Leaf nodes:

Leaf nodes contain at least n/2 record pointers and n/2 key values

At most, leaf nodes contain n record pointers and n key values

Every leaf node contains one block pointer P to point to next leaf node and forms a linked
list.

27
B+ tree insertion

B+ tree are filled from bottom. And each node is inserted at leaf node.

If leaf node overflows:

o Split node into two parts

o Partition at i = m+1/2
o First i entries are stored in one node

o Rest of the entries i+1onwards are moved to a new node

o ith key is duplicated in the parent of the leaf

If non-leaf node overflows:

o Split node into two parts

o Partition the node at i = m+1/2

o Entries upto i are kept in one node

o Rest of the entries are moved to a new node

B+ tree deletion

B+ tree entries are deleted leaf nodes.

The target entry is searched and deleted.

o If it is in internal node, delete and replace with the entry from the left position.

After deletion underflow is tested

o If underflow occurs

Distribute entries from nodes left to it.

o If distribution from left is not possible

Distribute from nodes right to it

o If distribution from left and right is not possible

28
 Merge the node with left and right to it.

Conclusion:

Thus B+ tree index is implemented.

29
 Experiment No. 8
Aim: Write a program to implement dynamic hashing on the database previously created.

Theory:

For a huge database structure it is not sometime feasible to search index through all its level and
then reach the destination data block to retrieve the desired data. Hashing is an effective
technique to calculate direct location of data record on the disk without using index structure.

It uses a function, called hash function and generates address when called with search key as
parameters. Hash function computes the location of desired data on the disk.

Hash Organization
Bucket: Hash file stores data in bucket format. Bucket is considered a unit of storage.
Bucket typically stores one complete disk block, which in turn can store one or more
records.

Hash Function: A hash function h, is a mapping function that maps all set of search-keys
K to the address where actual records are placed. It is a function from search keys to
bucket addresses.

Dynamic Hashing
Problem with static hashing is that it does not expand or shrink dynamically as the size of
database grows or shrinks. Dynamic hashing provides a mechanism in which data buckets are
added and removed dynamically and on-demand. Dynamic hashing is also known as extended
hashing.

Hash function, in dynamic hashing, is made to produce large number of values and only a few
are used initially.

30
 [Image: Dynamic Hashing]

Organization

The prefix of entire hash value is taken as hash index. Only a portion of hash value is used for
computing bucket addresses. Every hash index has a depth value, which tells it how many bits
are used for computing hash function. These bits are capable to address 2n buckets. When all
these bits are consumed, that is, all buckets are full, then the depth value is increased linearly and
twice the buckets are allocated.

Operation

Querying: Look at the depth value of hash index and use those bits to compute the
bucket address.

Update: Perform a query as above and update data.

Deletion: Perform a query to locate desired data and delete data.

Insertion: compute the address of bucket

o If the bucket is already full

Add more buckets

Add additional bit to hash value

Re-compute the hash function

o Else

Add data to the bucket

o If all buckets are full, perform the remedies of static hashing.

Hashing is not favorable when the data is organized in some ordering and queries require range
of data. When data is discrete and random, hash performs the best.

Hashing algorithm and implementation have high complexity than indexing. All hash operations
are done in constant time.

Conclusion:

31
Thus we have studied dynamic hashing concept.

32
 Experiment No: 9

Aim: Write a program to simulate log based protocol using immediate or deferred
database modification.

Theory:

Crash Recovery

Though we are living in highly technologically advanced era where hundreds of satellite monitor
the earth and at every second billions of people are connected through information technology,
failure is expected but not every time acceptable.

DBMS is highly complex system with hundreds of transactions being executed every second.
Availability of DBMS depends on its complex architecture and underlying hardware or system
software. If it fails or crashes amid transactions being executed, it is expected that the system
would follow some sort of algorithm or techniques to recover from crashes or failures.

Failure Classification

To see where the problem has occurred we generalize the failure into various categories, as
follows:

Transaction failure

When a transaction is failed to execute or it reaches a point after which it cannot be completed
successfully it has to abort. This is called transaction failure. Where only few transactions or
processes are hurt.

Reason for transaction failure could be:

Logical errors: where a transaction cannot complete because of it has some code error or
any internal error condition

System errors: where the database system itself terminates an active transaction because
DBMS is not able to execute it or it has to stop because of some system condition. For
example, in case of deadlock or resource unavailability systems aborts an active
transaction.

System crash

33
There are problems, which are external to the system, which may cause the system to stop
abruptly and cause the system to crash. For example interruptions in power supply, failure of
underlying hardware or software failure.

Examples may include operating system errors.

Disk failure:

In early days of technology evolution, it was a common problem where hard disk drives or
storage drives used to fail frequently.

Disk failures include formation of bad sectors, unreachability to the disk, disk head crash or any
other failure, which destroys all or part of disk storage

Storage Structure

We have already described storage system here. In brief, the storage structure can be divided in
various categories:

Volatile storage: As name suggests, this storage does not survive system crashes and
mostly placed very closed to CPU by embedding them onto the chipset itself for
examples: main memory, cache memory. They are fast but can store a small amount of
information.

Nonvolatile storage: These memories are made to survive system crashes. They are huge
in data storage capacity but slower in accessibility. Examples may include, hard disks,
magnetic tapes, flash memory, non-volatile battery backed-up RAM.

Recovery and Atomicity

When a system crashes, it many have several transactions being executed and various files
opened for them to modifying data items. As we know that transactions are made of various
operations, which are atomic in nature. But according to ACID properties of DBMS, atomicity of
transactions as a whole must be maintained that is, either all operations are executed or none.

When DBMS recovers from a crash it should maintain the following:

It should check the states of all transactions, which were being executed.

A transaction may be in the middle of some operation; DBMS must ensure the atomicity
of transaction in this case.

34
 It should check whether the transaction can be completed now or needs to be rolled back.

No transactions would be allowed to leave DBMS in inconsistent state.

There are two types of techniques, which can help DBMS in recovering as well as maintaining
the atomicity of transaction:

Maintaining the logs of each transaction, and writing them onto some stable storage
before actually modifying the database.

Maintaining shadow paging, where the changes are are done on a volatile memory and
later the actual database is updated.

Log-Based Recovery

Log is a sequence of records, which maintains the records of actions performed by a transaction.
It is important that the logs are written prior to actual modification and stored on a stable storage
media, which is failsafe.

Log based recovery works as follows:

The log file is kept on stable storage media

When a transaction enters the system and starts execution, it writes a log about it

<Tn, Start>

When the transaction modifies an item X, it write logs as follows:

<Tn, X, V1, V2>

It reads Tn has changed the value of X, from V1 to V2.

When transaction finishes, it logs:

<Tn, commit>

Database can be modified using two approaches:

1. Deferred database modification: All logs are written on to the stable storage and
database is updated when transaction commits.

35
 2. Immediate database modification: Each log follows an actual database modification.
That is, database is modified immediately after every operation.

Recovery with concurrent transactions

When more than one transaction are being executed in parallel, the logs are interleaved. At the
time of recovery it would become hard for recovery system to backtrack all logs, and then start
recovering. To ease this situation most modern DBMS use the concept of 'checkpoints'.

Checkpoint

Keeping and maintaining logs in real time and in real environment may fill out all the memory
space available in the system. At time passes log file may be too big to be handled at all.
Checkpoint is a mechanism where all the previous logs are removed from the system and stored
permanently in storage disk. Checkpoint declares a point before which the DBMS was in
consistent state and all the transactions were committed.

Recovery

When system with concurrent transaction crashes and recovers, it does behave in the following
manner:

[Image: Recovery with concurrent transactions]

The recovery system reads the logs backwards from the end to the last Checkpoint.

It maintains two lists, undo-list and redo-list.

If the recovery system sees a log with <Tn, Start> and <Tn, Commit> or just <Tn, Commit>, it
puts the transaction in redo-list.

If the recovery system sees a log with <Tn, Start> but no commit or abort log found, it puts
the transaction in undo-list.

36
All transactions in undo-list are then undone and their logs are removed. All transaction in redo-
list, their previous logs are removed and then redone again and log saved.

Conclusion:

Thus we have studied log based protocol.

37
 Experiment No.: 10

Aim: Write a program to simulate any one concurrency control protocol.

Theory:

In a multiprogramming environment where more than one transactions can be concurrently

executed, there exists a need of protocols to control the concurrency of transaction to ensure
atomicity and isolation properties of transactions.

Concurrency control protocols, which ensure serializability of transactions, are most desirable.
Concurrency control protocols can be broadly divided into two categories:

Lock based protocols

Time stamp based protocols

Lock based protocols

Database systems, which are equipped with lock-based protocols, use mechanism by which any
transaction cannot read or write data until it acquires appropriate lock on it first. Locks are of two
kinds:

Binary Locks: a lock on data item can be in two states; it is either locked or unlocked.

Shared/exclusive: this type of locking mechanism differentiates lock based on their uses.
If a lock is acquired on a data item to perform a write operation, it is exclusive lock.
Because allowing more than one transactions to write on same data item would lead the
database into an inconsistent state. Read locks are shared because no data value is being
changed.

There are four types lock protocols available:

Simplistic

Simplistic lock based protocols allow transaction to obtain lock on every object before 'write'
operation is performed. As soon as 'write' has been done, transactions may unlock the data item.

Pre-claiming

In this protocol, a transactions evaluations its operations and creates a list of data items on which
it needs locks. Before starting the execution, transaction requests the system for all locks it needs

38
beforehand. If all the locks are granted, the transaction executes and releases all the locks when
all its operations are over. Else if all the locks are not granted, the transaction rolls back and
waits until all locks are granted.

[Image: Pre-claiming]

Two Phase Locking - 2PL

This locking protocol is divides transaction execution phase into three parts. In the first part,
when transaction starts executing, transaction seeks grant for locks it needs as it executes.
Second part is where the transaction acquires all locks and no other lock is required. Transaction
keeps executing its operation. As soon as the transaction releases its first lock, the third phase
starts. In this phase a transaction cannot demand for any lock but only releases the acquired
locks.

[Image: Two Phase Locking]

Two phase locking has two phases, one is growing; where all locks are being acquired by
transaction and second one is shrinking, where locks held by the transaction are being released.

To claim an exclusive write lock, a transaction must first acquire a shared read lock and then
upgrade it to exclusive lock.

Strict Two Phase Locking

39
The first phase of Strict-2PL is same as 2PL. After acquiring all locks in the first phase,
transaction continues to execute normally. But in contrast to 2PL, Strict-2PL does not release
lock as soon as it is no more required, but it holds all locks until commit state arrives. Strict-2PL
releases all locks at once at commit point.

[Image: Strict Two Phase Locking]

Strict-2PL does not have cascading abort as 2PL does.

Time stamp based protocols

The most commonly used concurrency protocol is time-stamp based protocol. This protocol uses
either system time or logical counter to be used as a time-stamp.

Lock based protocols manage the order between conflicting pairs among transaction at the time
of execution whereas time-stamp based protocols start working as soon as transaction is created.

Every transaction has a time-stamp associated with it and the ordering is determined by the age
of the transaction. A transaction created at 0002 clock time would be older than all other
transaction, which come after it. For example, any transaction 'y' entering the system at 0004 is
two seconds younger and priority may be given to the older one.

In addition, every data item is given the latest read and write-timestamp. This lets the system
know, when was last read and write operation made on the data item.

Time-stamp ordering protocol

The timestamp-ordering protocol ensures serializability among transaction in their conflicting

read and write operations. This is the responsibility of the protocol system that the conflicting
pair of tasks should be executed according to the timestamp values of the transactions.

Time-stamp of Transaction Ti is denoted as TS(Ti).

Read time-stamp of data-item X is denoted by R-timestampX.

40
 Write time-stamp of data-item X is denoted by W-timestampX.

Timestamp ordering protocol works as follows:

If a transaction Ti issues readX operation:

o If TSTi < W-timestampX

Operation rejected.

o If TSTi >= W-timestampX

Operation executed.

o All data-item Timestamps updated.

If a transaction Ti issues writeX operation:

o If TSTi < R-timestampX

Operation rejected.

o If TSTi < W-timestampX

Operation rejected and Ti rolled back.

o Otherwise, operation executed.

Thomas' Write rule:

This rule states that in case of:

If TSTi < W-timestampX

Operation rejected and Ti rolled back. Timestamp ordering rules can be modified to make
the schedule view serializable. Instead of making Ti rolled back, the 'write' operation
itself is ignored.

Conclusion:

Thus we have studied different concurrency control protocol.

41