UNIT - V

Data on External storage

A DBMS stores the data on external storage because the amount of data is very
huge, must persist across program executions and has to be fetched into main
memory when DBMS processes the data.

The unit of information for reading data from disk, or writing data to disk, is a
page. The size of a page is 4KB or 8KB.

Memory in a computer system is arranged in a hierarchy, as shown in Figure. At

the top, we have primary storage, which consists of cache and main memory and
provides very fast access to data. Then comes secondary storage, which consists of
slower devices, such as magnetic disks (Floppy disk & Hard disk drive). Tertiary
storage is the slowest class of storage devices; for example, optical disks (CD) and
tapes.

Each record in a file has a unique identifier called a record id, or rid for short. A
rid has the property that we can identify the disk address of the page containing the
record by using the rid.

Buffer Manager:
Data is read into memory for processing, and written to disk for persistent storage,
by a layer of software called the buffer manager. When the files and access

228
methods layer (which we often refer to as just the file layer) needs to process a
page, it asks the buffer manager to fetch the page, specifying the page's rid. The
buffer manager fetches the page from disk if it is not already in memory.

Disk space manager:

Space on disk is managed by the disk space manager. When the files and access
methods layer needs additional space to hold new records in a file, it asks the disk
space manager to allocate an additional disk page for the file;

Magnetic Disks:
Magnetic disks support direct access (transfers the block of data between the
memory and peripheral devices of the system, without the participation of the
processor) to a desired location and are widely used for database applications. A
DBMS provides seamless access to data on disk; applications need not worry about
whether data is in main memory or disk.

229
Platter: A platter is a circular magnetic plate that is used for storing data in a hard
disk. It is often made of aluminum, glass substrate or ceramic. A hard disk drive
contains several platters. Each platter has two working surfaces. These surfaces of
the platters hold the recorded data.

Spindle: A typical HDD design consists of a spindle, which is a motor that holds
the platters.

230
Tracks: Each working surface of the platter is divided into number of concentric
rings, which are called tracks.

Cylinder: The collection of all the tracks that are of the same distance, from the
edge of the platter, is called a cylinder.

Read / Write Head: The data on a hard drive platter is read by read – write heads,
of read – write arm. The read – write arm also known as actuator.

Arm assembly: Each on a separate read – write arm are controlled by a common
arm assembly which moves all heads simultaneously from one cylinder to another.

Tracks: Each platter is broken into thousands of tightly packed concentric circles,
known as tracks. These tracks resemble the structure of annual rings of a tree. All
the information stored on the hard disk is recorded in tracks. Starting from zero at
the outer side of the platter, the number of tracks goes on increasing to the inner
side. Each track can hold a large amount of data counting to thousands of bytes.

Sectors: Each track is further broken down into smaller units called sectors. As
sector is the basic unit of data storage on a hard disk, each track has the same
number of sectors, which means that the sectors are packed much closer together
on tracks near the center of the disk. A single track typically can have thousands of
sectors. The data size of a sector is always a power of two, and is almost always
either 512 or 4096 bytes.

231
Clusters: Sectors are often grouped together to form clusters. A cluster is the
smallest possible unit of storage on a hard disk. If contiguous clusters (clusters that
are next to each other on the disk) are not available, the data is written elsewhere
on the disk, and the file is considered to be fragmented.

232
 File Organization and Indexing

A database consists of a huge amount of data. The data is grouped within a table in
RDBMS, and each table has related records. A user can see that the data is stored
in form of tables, but in actual this huge amount of data is stored in physical
memory in form of files.

File: A file is named collection of related information that is recorded on

secondary storage such as magnetic disks, optical disks.

File Organization:

File Organization refers to the logical relationships among various records that
constitute the file, particularly with respect to the means of identification and
access to any specific record. In simple terms, Storing the files in certain order is
called file Organization.

Indexing:

The main goal of designing the database is faster access to any data in the database
and quicker insert/delete/update to any data. When a database is very huge, even a
smallest transaction will take time to perform the action. In order to reduce the
time spent in transactions, Indexes are used. Indexes are similar to book catalogues
in library or even like an index in a book.

Indexing is a data structure technique which allows you to quickly retrieve records
from a database file. An Index is a small table having only two columns. The first
column comprises a copy of the primary or candidate key of a table. Its second
column contains a set of pointers for holding the address of the disk block where
that specific key value stored.
An index
 Takes a search key as input
 Efficiently returns a collection of matching records.

233
Types of Indexing:

Primary Index:

Primary Index is an ordered file which is fixed length size with two fields. The first
field is the same a primary key and second, filed is pointed to that specific data
block. In the primary Index, there is always one to one relationship between the
entries in the index table.

The primary Indexing in DBMS is also further divided into two types.
 Dense Index
 Sparse Index

Dense Index: In a dense index, a record is created for every search key valued in
the database. This helps you to search faster but needs more space to store index
records. In this Indexing, method records contain search key value and points to
the real record on the disk.

Dense Index

234
Sparse Index

It is an index record that appears for only some of the values in the file. Sparse
Index helps you to resolve the issues of dense Indexing in DBMS. In this method
of indexing technique, a range of index columns stores the same data block
address, and when data needs to be retrieved, the block address will be fetched.
However, sparse Index stores index records for only some search-key values. It
needs less space, less maintenance overhead for insertion, and deletions but It is
slower compared to the dense Index for locating records.

Clustered Indexing

Clustering index is defined on an ordered data file. The data file is ordered on a
non-key field. In some cases, the index is created on non-primary key columns
which may not be unique for each record. In such cases, in order to identify the
records faster, we will group two or more columns together to get the unique
values and create index out of them. This method is known as clustering index.
Basically, records with similar characteristics are grouped together and indexes are
created for these groups. Clustered index sorted according to first name (Search
key).
For example, students studying in each semester are grouped together. i.e. 1st
Semester students, 2nd semester students, 3rd semester students etc are grouped.

235
Example:

dno ----
1
B1 1
Key Pointer 2
1 . 2
2 . 3
3 . B2 3
4 . 3
5 . 4
6 . B3 4
4
5
B4 5
6
6

Secondary Index: Secondary index may be generated from a field which is a

candidate key and has a unique value in every record, or a non-key with duplicate
values.

Example:

eid Name Pan no

1 A 40 Key Pointer
2 B 51 23 .
3 A 62 33 .
4 C 33 40 .
5 A 71 51 .
6 D 82 62 .
7 E 91 71 .
8 F 23 82 .
9 K 100 91 .
10 L 120 100 .
11 M 150
12 C 136
13 . .

236
 INDEX DATA STRUCTURES

Hash Based Indexing

Hashing is the technique of the database management system, which directly finds
the specific data location on the disk without using the concept of index structure.

In the database systems, data is stored at the blocks whose data address is produced
by the hash function. That location of memory where hash files stored these records
is called as data bucket or data block.

Terms used in Hashing:

Data Bucket: That location of memory where the hash file stored the records. It is
also referred to as a Unit of storage.

Key: A key in the Database Management system (DBMS) is a field or set of fields
that helps the relational database users to uniquely identify the row/records of the
database table.

Hash function: This mapping function matches all the set of search keys to those
addresses where the actual records are located. It is an easy mathematics function.

Linear Probing: It is a concept in which the next available block of data is used for
inserting the new record instead of overwriting the older data block.

Quadratic Probing: It is a method that helps users to determine or find the address
of a new data bucket.

Double Hashing: Double hashing is a computer programming method used in hash

tables to resolve the issues of has a collision.

Bucket Overflow: When a record is inserted, the address generated by the hash
function is not empty or data already exists in that address .This situation is called
bucket overflow.

There are mainly two types of SQL hashing methods:

1. Static Hashing
2. Dynamic Hashing

237
Static Hashing: In the static hashing, the resultant data bucket address will always
remain the same.
Therefore, if you generate an address for say Student_ID = 10 using hashing function
mod(3), the resultant bucket address will always be 1. So, you will not see any
change in the bucket address.
Therefore, in this static hashing method, the number of data buckets in memory
always remains constant.

Static Hash Functions

Inserting a record: When a new record requires to be inserted into the table, you
can generate an address for the new record using its hash key. When the address is
generated, the record is automatically stored in that location.

Searching: When you need to retrieve the record, the same hash function should be
helpful to retrieve the address of the bucket where data should be stored.

Delete a record: Using the hash function, you can first fetch the record which is you
wants to delete. Then you can remove the records for that address in memory.

Static hashing is further divided into

1. Open hashing (Chaining)

2. Close hashing. (Linear probing, quadratic probing, Double hashing)

238
DYNAMIC HASHING TECHNIQUES
EXTENDIBLE HASHING

In Static Hashing the performance degrades with overflow pages. This problem,
however, can be overcome by a simple idea: Use a directory of pointers to buckets,
and double the size of the number of buckets by doubling just the directory and
splitting only the bucket that overflowed which the central concept of Extendible is
hashing.
It is a dynamic hashing method wherein directories and buckets are used to hash
data. It is an aggressively flexible method in which the hash function also
experiences dynamic changes.
Basic structure of Extendible hashing:

Frequently used terms in Extendible Hashing:

 Directories: These containers store pointers to buckets. Each directory is

given a unique id which may change each time when expansion takes place.
The hash function returns this directory id which is used to navigate to the
appropriate bucket. Number of Directories = 2^Global Depth.
 Buckets: They store the hashed keys. Directories point to buckets. A bucket
may contain more than one pointer to it if its local depth is less than the global
depth.
 Global Depth: It is associated with the Directories. They denote the number
of bits which are used by the hash function to categorize the keys. Global
Depth = Number of bits in directory id.
 Local Depth: It is the same as that of Global Depth except for the fact that
Local Depth is associated with the buckets and not the directories. Local depth

239
 in accordance with the global depth is used to decide the action that to be
performed in case an overflow occurs. Local Depth is always less than or equal
to the Global Depth.
 Bucket Splitting: When the number of elements in a bucket exceeds a
particular size, then the bucket is split into two parts.
 Directory Expansion: Directory Expansion Takes place when a bucket
overflows. Directory Expansion is performed when the local depth of the
overflowing bucket is equal to the global depth.

Example based on Extendible Hashing: Now, let us consider a prominent example

of hashing the following elements: 16,4,6,22,24,10,31,7,9,20,26.
Bucket Size: 3 (Assume)
Hash Function: Suppose the global depth is X. Then the Hash Function returns X
LSBs.
Solution: First, calculate the binary forms of each of the given numbers.

16 10000
4 00100
6 00110
22 10110
24 11000
10 01010
31 11111
7 00111
9 01001
20 10100
26 11010

Initially, the global-depth and local-depth is always 1. Thus, the hashing frame looks
like this:

240
Inserting 16: The binary format of 16 is 10000 and global-depth is 1. The hash
function returns 1 LSB of 10000 which is 0. Hence, 16 is mapped to the
directory with id=0.

Inserting 4 and 6: Both 4(100) and 6(110) have 0 in their LSB. Hence, they are
hashed as follows:

Inserting 22: The binary form of 22 is 10110. Its LSB is 0. The bucket pointed by
directory 0 is already full. Hence, Over Flow occurs.

Since Local Depth = Global Depth, the bucket splits and directory expansion takes
place. Also, rehashing of numbers present in the overflowing bucket takes place
after the split. And, since the global depth is incremented by 1, now, the global
depth is 2. Hence, 16,4,6,22 are now rehashed w.r.t 2 LSBs.[
16(10000),4(100),6(110),22(10110) ]

241
  Notice that the bucket which was underflow has remained untouched. But,
since the number of directories has doubled, we now have 2 directories 01 and
11 pointing to the same bucket. This is because the local-depth of the bucket
has remained 1. And, any bucket having a local depth less than the global
depth is pointed-to by more than one directory.

Inserting 24 and 10: 24(11000) and 10 (1010) can be hashed based on directories
with id 00 and 10. Here, we encounter no overflow condition.

Inserting 31, 7, 9: All of these elements [31(11111), 7(111), 9(1001)] have either 01
or 11 in their LSBs. Hence, they are mapped on the bucket
pointed out by 01 and 11. We do not encounter any overflow
condition here.

242
Inserting 20: Insertion of data element 20 (10100) will again cause the overflow
problem.

20 is inserted in bucket pointed out by 00. Since the local depth of the bucket =
global-depth, directory expansion (doubling) takes place along with bucket splitting.
Elements present in overflowing bucket are rehashed with the new global depth.
Now, the new Hash table looks like this:

243
Inserting 26: Global depth is 3. Hence, 3 LSBs of 26(11010) are considered.
Therefore 26 best fits in the bucket pointed out by directory 010.

The bucket overflows, and, since the local depth of bucket < Global depth (2<3),
directories are not doubled but, only the bucket is split and elements are rehashed.
Finally, the output of hashing the given list of numbers is obtained.

Hashing of 11 Numbers is Thus Completed.

244
LINEAR HASHING

Linear Hashing is a dynamic hashing technique, it does not require a directory,

deals naturally with collisions, and offers a lot of flexibility with respect to the
timing of bucket splits. If the data distribution is much skewed, however, overflow
chains could cause Linear Hashing performance to be worse than that of
Extendible Hashing.

The scheme utilizes a family of hash functions h0, h1, h2, ... , with the property
that each function's range is twice that of its predecessor. That is, if hi maps a data
entry into one of M buckets, hi+1 maps a data entry into one of M buckets. Such a
family is typically obtained by choosing a hash function h and an initial number N
of buckets,2 and defining hi(value) = h(value) mod (2i N).

The idea is best understood in terms of rounds of splitting. During round number
Level, only hash functions hLevel and hLevel+1 are in use. The buckets in the file
at the beginning of the round are split, one by one from the first to the last bucket,
thereby doubling the number of buckets. At any given point within a round,
therefore, we have buckets that have been split, buckets that are yet to be split, and
buckets created by splits in this round.

Consider how we search for a data entry with a given search key value. We apply
hash function h Level , and if this leads us to one of the unsplit buckets, we simply
look there. If it leads us to one of the split buckets, the entry may be there or it may
have been moved to the new bucket created earlier in this round by splitting this
bucket; to determine which of the two buckets contains the entry, we apply
hLevel+1.

Database Management Systems G Deepak, Asst.Prof, KITS(S)

245
246
247
 Tree Based Indexing
1. ISAM (Indexed sequential access method)
- Static Index Structure
2. B+ Trees
- Dynamic Index Structure

B+ Tree: B+ tree is dynamic index structure i.e the height of the tree grows and
contracts as records are added and deleted.
A B+ tree is also known as balanced tree in which every path from the root of the
tree to a leaf is of the same length.
Leaf node of B+ trees are linked, so doing a linear search of all keys will require
just one pass through all the leaf nodes.
B+ tree combines features of ISAM and B tress. It contains index pages and data
pages. The data pages always appear as leaf nodes in the tree. The root node and
intermediate nodes are always index pages. These features are similar to ISAM
unlike ISAM, overflow pages are not used in B+ trees.
For order M
 Maximum number of keys per node =M-1
 Minimum Number of keys per node= ceil (M/2)-1
 Maximum number of pointers / children per node=M
 Minimum number of pointers / children per node=ceil (M/2)

Steps for insertion in B+ Tree

1. Every element is inserted into a leaf node. So, go to the appropriate leaf
node.
2. Insert the key into the leaf node in increasing order only if there is no
overflow. If there is an overflow goes ahead with the following steps
mentioned below to deal with overflow while maintaining the B+ Tree
properties.
Properties for insertion B+ Tree
Case 1: Overflow in leaf node
1. Split the leaf node into two nodes.
2. First node contains ceil ((m-1)/2) values.
3. Second node contains the remaining values.

248
 4. Copy the smallest search key value from second node to the parent
node.(Right biased)
Case 2: Overflow in non-leaf node
1. Split the non leaf node into two nodes.
2. First node contains ceil (m/2)-1 values.
3. Move the smallest among remaining to the parent.
4. Second node contains the remaining keys.

Example:
Problem: Insert the following key values 6, 16, 26, 36, 46 on a B+ tree with order = 3.
Solution:
Step 1: The order is 3 so at maximum in a node so there can be only 2 search key values. As
insertion happens on a leaf node only in a B+ tree so insert search key value 6 and 16 in
increasing order in the node. Below is the illustration of the same:

Step 2: We cannot insert 26 in the same node as it causes an overflow in the leaf
node, We have to split the leaf node according to the rules. First part contains
ceil((3-1)/2) values i.e., only 6. The second node contains the remaining values i.e.,
16 and 26. Then also copy the smallest search key value from the second node to
the parent node i.e., 16 to the parent node. Below is the illustration of the same:

249
Step 3: Now the next value is 36 that is to be inserted after 26 but in that node, it
causes an overflow again in that leaf node. Again follow the above steps to split
the node. First part contains ceil ((3-1)/2) values i.e., only 16. The second node
contains the remaining values i.e., 26 and 36. Then also copy the smallest search
key value from the second node to the parent node i.e., 26 to the parent node.
Below is the illustration of the same: The illustration is shown in the diagram
below.

Step 4: Now we have to insert 46 which is to be inserted after 36 but it causes an

overflow in the leaf node. So we split the node according to the rules. The first part
contains 26 and the second part contains 36 and 46 but now we also have to copy
36 to the parent node but it causes overflow as only two searches key values can be
accommodated in a node. Now follow the steps to deal with overflow in the non-
leaf node.

First node contains ceil (3/2)-1 values i.e. ’16’.

Move the smallest among remaining to the parent i.e ’26’ will be the new parent
node.
The second node contains the remaining keys i.e ’36’ and the rest of the leaf nodes
remain the same. Below is the illustration of the same:

250
Deletion in B+ tree:
Before going through the steps below, one must know these facts about a B+ tree
of degree m.
1. A node can have a maximum of m children.
2. A node can contain a maximum of m - 1 keys.
3. A node should have a minimum of ⌈m/2⌉ children.
4. A node (except root node) should contain a minimum of ⌈m/2⌉ - 1 keys.

While deleting a key, we have to take care of the keys present in the internal
nodes (i.e. indexes) as well because the values are redundant in a B+ tree.
Search the key to be deleted then follow the following steps.
Case I
The key to be deleted is present only at the leaf node not in the indexes (or internal
nodes). There are two cases for it:
1. There is more than the minimum number of keys in the node. Simply delete
the key.

M=3,
Max. Children=3
Min. Children=ceil (3/2)=2
Max.Keys=m-1=2
Min.keys=ceil (3/2)-1=1

Deleting 40 from B-tree

251
2. There is an exact minimum number of keys in the node. Delete the key and
borrow a key from the immediate sibling. Add the median key of the sibling
node to the parent.

Deleting 5 from B-tree

252
Case II
The key to be deleted is present in the internal nodes as well. Then we have to
remove them from the internal nodes as well. There are the following cases for this
situation.
1. If there is more than the minimum number of keys in the node, simply delete
the key from the leaf node and delete the key from the internal node as well.
Fill the empty space in the internal node with the inorder successor.

Deleting 45

253
2. If there are an exact minimum number of keys in the node, then delete the
key and borrow a key from its immediate sibling (through the parent).
Fill the empty space created in the index (internal node) with the borrowed
key.

Deleting 35

254
3. This case is similar to Case II(1) but here, empty space is generated above
the immediate parent node.
After deleting the key, merge the empty space with its sibling.
Fill the empty space in the grandparent node with the inorder successor.

255
Case III
In this case, the height of the tree gets shrinked. It is a little complicated.Deleting
55 from the tree below leads to this condition. It can be understood in the
illustrations below.

256
 ISAM Trees
 Indexed Sequential Access Method (ISAM) trees
are static
Root
40

Non-Leaf
Pages
20 33 51 63

Leaf 10* 15* 20* 27* 33* 37* 40* 46* 51* 55* 97*
63*
Pages

E.g., 2 Entries Per Page

257
 ISAM Trees: Page Overflows
 What if there are a lot of insertions after creating
the tree?

Non-leaf
Pages

Leaf
Pages
Overflow
page
Primary pages

258
 ISAM File Creation
 How to create an ISAM file?
 All leaf pages are allocated sequentially and
sorted on the search key value

 If Alternative (2) or (3) is used, the data records

are created and sorted before allocating
leaf pages

 The non-leaf pages are subsequently allocated

259
 ISAM: Searching for Entries
 Search begins at root, and key comparisons direct it
to a leaf

 Search for 27*

Root
40

20 33 51 63

10* 15* 20* 27* 33* 37* 40* 46* 51* 55* 63* 97*

260
 ISAM: Inserting Entries
 The appropriate page is determined as for a search, and the
entry is inserted (with overflow pages added if necessary)

 Insert 23*
Root
40

20 33 51 63

10* 15* 20* 27* 33* 37* 40* 46* 51* 55* 63* 97*

23*
261
 ISAM: Inserting Entries
 The appropriate page is determined as for a search, and the
entry is inserted (with overflow pages added if necessary)

 Insert 48*
Root
40

20 33 51 63

10* 15* 20* 27* 33* 37* 40* 46* 51* 55* 63* 97*

23* 48*

262
 ISAM: Inserting Entries
 The appropriate page is determined as for a search, and the
entry is inserted (with overflow pages added if necessary)

 Insert 41*
Root
40

20 33 51 63

10* 15* 20* 27* 33* 37* 40* 46* 51* 55* 63* 97*

23* 48* 41*

263
 ISAM: Inserting Entries
 The appropriate page is determined as for a search, and the
entry is inserted (with overflow pages added if necessary)

 Insert 42*
Root
40

20 33 51 63

10* 15* 20* 27* 33* 37* 40* 46* 51* 55* 63* 97*

23* 48* 41*

Chains of overflow pages can easily develop2!64 42*

 ISAM: Deleting Entries
 The appropriate page is determined as for a search, and the
entry is deleted (with ONLY overflow pages removed when
becoming empty)

Root
 Delete 42* 40

20 33 51 63

10* 15* 20* 27* 33* 37* 40* 46* 51* 55* 63* 97*

23* 48* 41*

265 42*
 ISAM: Deleting Entries
 The appropriate page is determined as for a search, and the
entry is deleted (with ONLY overflow pages removed when
becoming empty)

Root
 Delete 42* 40

20 33 51 63

10* 15* 20* 27* 33* 37* 40* 46* 51* 55* 63* 97*

23* 48* 41*

266
 ISAM: Deleting Entries
 The appropriate page is determined as for a search, and the
entry is deleted (with ONLY overflow pages removed when
becoming empty)

Root
 Delete 42* 40

20 33 51 63

10* 15* 20* 27* 33* 37* 40* 46* 51* 55* 63* 97*

23* 48* 41*

267
 ISAM: Deleting Entries
 The appropriate page is determined as for a search, and the
entry is deleted (with ONLY overflow pages removed when
becoming empty)

Root
 Delete 51* 40

20 33 51 63

10* 15* 20* 27* 33* 37* 40* 46* 51* 55* 63* 97*

23* 48* 41*

Note that 51 still appears in an i2n6d8ex entry, but not in the leaf!
 ISAM: Deleting Entries
 The appropriate page is determined as for a search, and the
entry is deleted (with ONLY overflow pages removed when
becoming empty)

Root
 Delete 55* 40

20 33 51 63

10* 15* 20* 27* 33* 37* 40* 46* 55* 63* 97*

23* 48* 41*

Primary pages are NOT remove2d6,9even if they become empty!

 ISAM: Some Issues
 Once an ISAM file is created, insertions and deletions affect only
the contents of leaf pages (i.e., ISAM is a static structure!)

 Since index-level pages are never modified, there is no need to

lock them during insertions/deletions
 Critical for concurrency!

 Long overflow chains can develop easily

 The tree can be initially set so that ~20% of each page is free

 If the data distribution and size are relatively static, ISAM might
be a good choice to pursue!

270
File Organization

 The File is a collection of records. Using the primary key, we can access the
records. The type and frequency of access can be determined by the type of
file organization which was used for a given set of records.
 File organization is a logical relationship among various records. This
method defines how file records are mapped onto disk blocks.

Types of file organization:

File organization contains various methods. These particular methods have pros
and cons on the basis of access or selection. In the file organization, the
programmer decides the best-suited file organization method according to his
requirement.
Types of file organization are as follows:

1. Sequential file organization

2. Heap file organization
3. Hash file organization
4. Cluster file organization
5. B+ Tree File Organization

Sequential file organization

This method is the easiest method for file organization. In this method, files are
stored sequentially. This method can be implemented in two ways:

1. Pile File Method:

 It is a quite simple method. In this method, we store the record in a
sequence, i.e., one after another. Here, the record will be inserted in the
order in which they are inserted into tables.
 In case of updating or deleting of any record, the record will be searched in
the memory blocks. When it is found, then it will be marked for deleting,
and the new record is inserted.

271
Insertion of the new record:
Suppose we have four records R1, R3 and so on up to R9 and R8 in a sequence.
Hence, records are nothing but a row in the table. Suppose we want to insert a new
record R2 in the sequence, then it will be placed at the end of the file. Here,
records are nothing but a row in any table.

2. Sorted File Method:

 In this method, the new record is always inserted at the file's end, and then it
will sort the sequence in ascending or descending order. Sorting of records is
based on any primary key or any other key.
 In the case of modification of any record, it will update the record and then
sort the file, and lastly, the updated record is placed in the right place.

272
Insertion of the new record:

Suppose there is a preexisting sorted sequence of four records R1, R3 and so on

upto R6 and R7. Suppose a new record R2 has to be inserted in the sequence, then
it will be inserted at the end of the file, and then it will sort the sequence.

Heap file organization

 It is the simplest and most basic type of organization. It works with data
blocks. In heap file organization, the records are inserted at the file's end.
When the records are inserted, it doesn't require the sorting and ordering of
records.
 When the data block is full, the new record is stored in some other block.
This new data block need not to be the very next data block, but it can select
any data block in the memory to store new records. The heap file is also
known as an unordered file.
 In the file, every record has a unique id, and every page in a file is of the
same size. It is the DBMS responsibility to store and manage the new
records.

273
Insertion of a new record
Suppose we have five records R1, R3, R6, R4 and R5 in a heap and suppose we
want to insert a new record R2 in a heap. If the data block 3 is full then it will be
inserted in any of the database selected by the DBMS, let's say data block 1.

If we want to search, update or delete the data in heap file organization, then we
need to traverse the data from staring of the file till we get the requested record.
If the database is very large then searching, updating or deleting of record will be
time-consuming because there is no sorting or ordering of records. In the heap file
organization, we need to check all the data until we get the requested record.

Hash File Organization

Hash File Organization uses the computation of hash function on some fields of the
records. The hash function's output determines the location of disk block where the
records are to be placed.

274
When a record has to be received using the hash key columns, then the address is
generated, and the whole record is retrieved using that address. In the same way,
when a new record has to be inserted, then the address is generated using the hash
key and record is directly inserted. The same process is applied in the case of
delete and update.

In this method, there is no effort for searching and sorting the entire file. In this
method, each record will be stored randomly in the memory.

275
B+ Tree File Organization

B+ Tree is a data structure, which uses a tree-like structure for storing and
accessing the records or data from the file.
It is an enhanced method of an ISAM (Indexed Sequential Access Method). This
file organization stores that data which is not fit in the system’s main memory.
This file organization uses the concept of key-index. This concept uses the primary
key for the sorting of records. An index value of the database record is the record
address of the file.
B+ tree is the same as a binary search tree. But, this type of tree can have more
than two children. In this type of file organization, all the records or information
are stored at the leaf nodes. And the intermediate nodes act as the pointer to the
nodes which store the records, i.e., leaf nodes. Intermediate nodes in the tree do not
contain any information. Following diagram shows how the values are stored in the
B+ Tree File organization:

In this B+ tree, 30 is the only root node of the tree, which is also known as the
main node of the B+ tree. There exists an intermediary layer with the nodes, which
stores the address of the leaf nodes, not the actual records. Only the leaf nodes
contain the records in the order which is sorted.

In the above B+ tree, only one leaf node exists whose values are: 10, 15, 22, 26,
28, 33, 34, 38, 40. As all the leaf nodes of the tree are sorted, so the records can be
easily searched.

276
Clustered File Organization

Cluster is defined as “when two or more related tables or records are stored within
the same file”. The related column of two or more database tables in the cluster is
called the cluster key. And this cluster key is used to map the two tables together.
This method minimizes the cost of accessing and searching the various records
because they are combined and available in a single cluster.
Example:
Suppose we have two tables whose names are Student and Subject. Both of the
following given tables are related to each other.

Student

Student_ID Student_Name Student_Age Subject_ID

101 Raju 20 C01
102 Ravi 20 C04
103 Rajesh 21 C01
104 Ranjith 22 C02
105 Rahul 21 C03
106 Ramesh 20 C04
107 Ravinder 20 C03
108 Rudra 21 C04

Subject

Subject_ID Subject_Name
C01 Math
C02 Java
C03 C
C04 DBMS

Therefore, both these tables ‘student’ and ‘subject’ are allowed to combine using a
join operation and can be seen as following in the cluster file.

Student + Subject

277
 Cluster Key
Subject_ID Subject_Name Student_ID Student_Name Student_Age
C01 Math 101 Raju 20
103 Ravi 21
C02 Java 104 Rajesh 22
C03 C 105 Ranjith 21
107 Rahul 20
C04 DBMS 102 Ramesh 20
106 Ravinder 20
108 Rudra 21

If we have to perform the insert, update and delete operations on the record, then
we can perform them directly because the data is sorted on that key with which
searching and accessing is done. In the given table (Student + Subject), the cluster
key is a Subject_ID.

Sequential Heap/Direct Hash ISAM B+ tree Cluster

Method of Stored as they Stored at the Stored at the Address index is Stored in a Frequently
storing come or end of the file. hash address appended to the tree like joined
sorted as they But the generated record structure tables are
come address in the clubbed
memory is into one
random. file based
on cluster
key
Types Pile file and Static and Dense, Sparse, Indexed
sorted file dynamic multilevel indexing and Hash
Method hashing
Design Simple Simplest Medium Complex Complex Simple
Design
Storage Cost Cheap Cheap Medium Costlier Costlier Medium
(magnetic
tapes)
Advantage Fast and Best suited for Faster Access Searching records is Searching Best suited
efficient when bulk insertion, No Need to faster. range of data for
there is large and small Sort Suitable for large & partial frequently
volumes of files/tables Handles database. data are joined

278
 data, Report multiple Any of the columns efficient. tables.
generation, transactions can be used as key No Suitable for
statistical Suitable for column. Searching performance 1:M
calculations Online range of data & degrades mappings
etc transactions partial data are when there is
efficient. insert / delete
/ update.
Grows and
shrinks with
data.
Works well
in secondary
storage
devices and
hence
reducing disk
I/O.
Since all
datas are at
the leaf node,
searching is
easy.
All data at
leaf node are
sorted
sequential
linked list.

Disadvantage Records are Accidental Not

scattered in Deletion or suitable for
the memory updation of large
and they are Data database.
Sorting of
inefficiently Use of Extra cost to Suitable
data each
used. Hence Memory is maintain index. only for the
time for
increases the inefficient File reconstruction is Not suitable joins on
insert/delete/
memory size. Searching needed as for static which
update takes
range of data, insert/update/delete. tables clustering
time and
Proper partial data, Does not grow with is done.
makes system
memory non-hash key data. Less
slow
management column, frequently
is needed. searching used joins
single hash and 1: 1
Not suitable column when Mapping

279
for large multiple hash are
tables. keys present inefficient.
or frequently
updated
column as
hash key are
inefficient.

280
Indexes and Performance Tuning

An index is a copy of selected columns of data from a table that can be searched
very efficiently. Although indexing does add some overheads in the form of
additional writes and storage space to maintain the index data structure, the key
focus of implementing index – in various available ways – is to improve the
lookup mechanism.

It must improve the performance of data matching by reducing the time taken to
match the query value.

Now, let’s understand how index is actually programmed and stored and what
causes the speed when an index is created.

Index entries are also "rows", containing the indexed column(s) and some sort of
pointing / marking data into the base table data. When an index is used to fetch a
row, the index is walked until it finds the row(s) of interest, and the base table is
then looked up to fetch the actual row data.

When a data is inserted, a corresponding row is written to the index, and when a
row is deleted, its index row is taken out. This keeps the data and searching index
always in sync making the lookup very fast and read-time efficient.

Performance tuning is the process of making SQL statements run as smoothly as

possible by finding and taking the quickest route to answer a query

281
Indexing is implemented using specific architecture and approaches. Some
architectures worth mentioning are:

create table test(roll int,name char(50),job char(50));

insert into test values(2,'raju','software');
insert into test values(1,'ravi','teacher');
insert into test values(3,'raju','software');
delete from test where roll=2;
select * from test;
create clustered index roll_index on test(roll);
create nonclustered index job_index on test(job);

Clustered Index:
A clustered indexed is similar to telephone directory, where data is arranged by
first name...
A table can have only one clustered index, However, one clustered index can have
multiple columns. Similar to telephone directory is arranged by first name and last
name

Non-clustered index:
A nonclustered indexed is similar to the index in textbook, where data is stored at
one place and index is stored in another place.
2. The index has pointers to the storage location.
3. Since, Nonclustered index are stored separately, a table can have more than one
Nonclustered index
4. In the index itself, data is stored in ascending or descending order of the index

282
References:
 Ramakrishnan - Database Management Systems 3rd Edition
 Korth Database System Concepts 6th edition
 Database Systems - Design, Implementation, and Management (9th Edition)
 Fundamentals-of-Database-Systems-Pearson-2015-Ramez-Elmasri-
Shamkant-B.-Navathe
 An Introduction to Database Systems, 8th Edition, C J Date
 www.guru99.com
 https://www.programiz.com/
 www.javatpoint.com
 www.geeksforgeeks.org
 www.tutorialspoint.com
 searchsqlserver.techtarget.com
 https://beginnersbook.com
 https://www.gatevidyalay.com
 Gate Smashers
 Education 4u
 Jenny's lectures
 KNOWLEDGE GATE

283