Database Systems Journal vol. II, no.

2/2011 13

Increasing Database Performance using Indexes

Cecilia CIOLOCA, Mihai GEORGESCU

Economic Informatics Department, Academy of Economic Studies
Bucharest, ROMANIA
cecilia_cioloca@yahoo.com, mihai.georgescu@europe.com

The performance issues are presented. The process of performance tuning is described. The
indexing concept is introduced. The two types of defining an index are identified. The paper
presents and explains the way a clustered and nonclustered index works. A compared analysis
between clustered and nonclustered indexes is created. The benefits of using indexes on
databases are identified and explained. A demonstration of using SEEK and SCAN indexes is
presented, showing the logic behind these two types of indexes. Cases when an index must be
used and how this index is created, are presented along with the performance improvement
that is obtained after successfully creating the index.
Keywords: Clustered index, Nonclustered index, Optimization, Database, Performance

1 Introduction
Performance is one of the most
important metric that describes if a
Time response measurement after
tuning.
The database designer should focus on those
project is a success or a mistake. It is also techniques that provide the most benefits.
one of the most common problems the Among all the techniques of improving the
programmers are dealing with. Either if database performance, indexing and query
we are taking into consideration a new optimization stand up as they provide visible
starting project or an application that is results. On the other hand, abusing indexes
already running on production we should and inappropriate indexes might harm the
always keep in mind the performance performance of the system.
aspects. This means that the design for The structure of the database used for
performance process should start early in this demonstration is described in figure 1.
the development of an application. The
architecture of the system should be
design in a manner to meet the
performance requirements and to allow
performance tuning. The book [1]
presents techniques to improve or fine
tune a database to achieve maximum
performance. Fig. 1 Structure of test database
There is no recipe of designing perfect
databases, but there are techniques and In order to define the index concept we
tips that can improve the quality of the will take a look at how the data is retrieved
design. Improving the database from database with no indexes.
performance is a cycling activity that
should be including in each of SELECT * FROM Client WHERE
LastName = LastName4
development stage.
The performance tuning process includes
In the above query the SQL Server will
three steps:
look in all the rows from the beginning of
Time response measurement before
the table to the end of it searching for those
tuning;
rows that are meeting the condition in the
Tuning performed;
14 Increasing Database Performance using Indexes

WHERE clause. If the searched table the data in the table is physically
contains few rows the response of the alphabetically sorted based on FirstName
above query might be very prompt, but in value. When inserting a new row into the
case of tables that contain millions of database, it will be inserted in a certain
rows the query might take a while. For position so that the sorting is still kept.
this reason creating an index on the table Figure 2 schematically presents the tree
allows SQL Server to get the result structure of the clustered index on Client
without searching the whole data in the table column FirstName.
table. Indexing is the best way to reduce
the logical read and disk input/output as it
provides a mechanism of structured
search instead of row by row search [8].
Basically an index is a copy of the data in
the table, sorted in a certain logical
manner. There are two different ways of
defining an index:
Like a dictionary: a dictionary is a
list of words ordered alphabetically.
An index defined like a dictionary
is a set of data ordered in a Fig. 2 The structure of the clustered
lexicographic manner. For this index
reason the search on the index will
not include all the rows but will As shown in the figure above the leaf nodes
position easier based on the ordered represent the actual data pages while the
data. intermediate nodes of the tree structure are
Like a book index: this approach of
index pages. All the pages in the structure
creating an index will not alter the are linked. The top node in the structure is
layout of the data in the table, but the root index page, while the middle level
just like the index of a book will nodes are intermediate index pages. Each
position the data in the table to the row in an index page refers either another
corresponding position in the table. index page or a data page. This reference is
An index defined in this manner a pointer to a page number. The root index
will contain the data in the indexed page contains a row with the value
column and the corresponding row Munteanu which points to the intermediate
number of the data. index page number 98, while the index page
An example of how to design a spatial 98 contains a row with the value Danila
database is presented in detail in [3]. which points to the data page 78. The data
page 78 contains two rows with the
2 Clustered indexes corresponding values.
A clustered index is an index that When searching using the clustered index,
contains the table data ordered in a the row to row search will be avoided. For
physical manner. When creating a the following query
clustered index on a table, the data rows
are reordered on the disk based on the SELECT * FROM Client WHERE
index key sequence so that it meets the LastName=Cioloca
indexed ordering. For this reason only
one clustered index is allowed to be SQL Server will first get the root index page
created on one single table. from the sysindexes table, and then it will
For the Client table, when creating a search in the rows of it to find the highest
clustered index on FirstName column, key value not greater then Cioloca, and will
Database Systems Journal vol. II, no. 2/2011 15

find the value Arsene. The pointer

corresponding to the key value Arsene When using clustered indexes there are
refers to the index page 22. Now, SQL few aspects that should be taken into
Server will move to index page 22, where consideration:
it looks again for the highest key value
not greater than the searched value. This The clustered index should be created
value is Craciun and it points to the data prior the nonclustered index. The
page 66. SQL Server moves to the data reason why this is recommended is
page 66, where it finds the two rows: that the nonclustered index row
Craciun Ciprian and Cioloca Cecilia. It locators should point to a
finds the value that meats the search corresponding key value in the
criteria and returns it. clustered index. If the nonclustered
A table that has no clustered index is index is created first then the row
called heap table. The data in this type of locators will point into the heap and
table is not stored in any particular order. the relationship between the clustered
Each row in a nonclustered index has a and nonclustered indexes will be
pointer that refers to the location of that compromised;
particular data row. This pointer is called The reordering of the index occurs
raw locator, and it can point to a row in every time the index is changed. The
the heap or to a clustered index key dependency between the clustered and
value, depending if the table has or not a nonclustered indexes should be kept in
clustered index. If the table has no mind when changing the clustered
clustered index then the row located will index. For this reason the index should
point to a data row in the heap. In case be dropped and then recreated so that
the table has a clustered index, the row the nonclustered are rebuilt correctly;
locator will point to a index key value The clustered index is not
into the clustered index. In the figure 3 recommended to be used when
the relationship between clustered and working with columns that are
nonclustered indexes is presented. frequently updated as each time the
column is updated the clustered and
nonclustered indexes must be rebuild;
The clustered index is efficient when
retrieving presorted data and when
retrieving range of data.
As recommended in [2], a clustered index
should be used when: Consider using a
clustered index when the following occur:
The physical ordering supports the
range retrievals of important queries, or
equality returns many duplicates;
The clustered index key is used in the
ORDER BY clause or GROUP BY clause of
critical queries;
The clustered index key is used in
important joins to relate the tablesthat is,
it supports the foreign key;
The clustered index columns are not
changed regularly.
Fig. 3 Relationship clustered-
nonclustered indexes
16 Increasing Database Performance using Indexes

3 Nonclustered indexes order to point to the new datapage. This

Similar to the clustered indexes, involves a new level of indirection. The leaf
nonclustered indexes are balanced tree index nodes from the nonclustered index
structures that start from a root index still point to the old data page, while these
node, and include intermediate index old data pages are pointing to the new ones.
nodes and leaf nodes. The main This way the user is transferred to the new
differences between clustered and location of the data pages.
nonclustered indexes is that in case of While there can be only one single clustered
nonclustered indexes the key values are index for each table, there can be a bunch of
not ordered in any specific way and that nonclustered indexes on the same table. The
the leaf nodes from nonclustered indexes reason of that is that this type of index does
are not data pages but index pages that not change the physical order of the data
point to either a index node into a into the table.
clustered index or to a data row into the When using nonclustered indexes it is useful
heap. Figure 3 describes the tree structure to keep in mind the following aspects:
of a nonclustere node. The dotted line Nonclustered indexes might be find
suggests that the leaf nodes point to data very usefull when retrieving a small
rows into the heap table. set of data from a large amount of data.
The nonclustered indexes is also
recommended when using wide keys
and when the table columns are
frequently updated;
Nonclustered indexes are not the best
when retrieving large sets of data, as
by using this type of index there still
must be read a large amount of data
pages. In this case the use of clustered
indexes is recommended.

Using noncluster indexes should be used

when:
Fig. 3 Structure of nonclustered Once or more rows will be retrieved
index that is, the query is highly selective.
The nonclustered index key is used in
Due to its properties, a nonclustered the ORDER BY clause or GROUP BY
index does not physically change the clause of critical queries.
order of the rows into the table. The The nonclustered index key is used in
figure above also shows that each data important joins to relate the tables.
row is pointed by an index node, which A covered query is required.
was not the case for clustered index. The
nonclustered index is larger than its 4 Index SEEK versus Index SCAN
counterpart, as a supplementary index In order to evaluate the performance of an
level is introduced and it has to contain sql query, one of the most common tool is
the pointers to the data rows. SQL Server trace which provides
Even when the clustered index rows have information about the logical reads
physically changed the nonclustered row counter.
locaters continue to point to the same As shown in [7], the logical and physical
clustered index nodes. Instead of reads are explained: The I/O from an
updating each row locator for each instance of SQL Server is divided into
nonclustered index node, SQL Server logical and physical I/O. A logical read
adds a pointer to the old data page in
Database Systems Journal vol. II, no. 2/2011 17

occurs every time the database engine

requests a page from the buffer cache. If
We observe for the first query that SQL
the page is not currently in the buffer
Server requested a page from the buffer
cache, a physical read is then performed
cache only 15 times. Also in figure 5, by
to read the page into the buffer cache. If
examining the execution plan, the database
the page is currently in the cache, no
engine used an Index Seek to fetch the
physical read is generated; the buffer
information that was already sorted using
cache simply uses the page already in
the LastNameIndex that we created earlier.
memory.
The second query used an Index Scan which
Physical and logical reads are available in
means that the entire Client table was
SQL Server 2008 by using the following
scanned to find the Clients that have
command:
LastName = LastName4 and requested
SET STATISTICS IO ON data from cache 19458 times, a lot more
than the first query which used the index.
After successfully running this command, Another information that the execution plan
all future queries will show the operations provides is the query cost. For the first query
performed. is almost 0% compared to the second query
First we will create a nonclustered index which scanned the entire table.
on column LastName:
Query 1:
CREATE NONCLUSTERED INDEX (4 row(s) affected)
LastNameIndex on Client(LastName) Table 'Client'. Scan count 1, logical reads
15, physical reads 0, read-ahead reads 0, lob
logical reads 0, lob physical reads 0, lob
By using the system procedure read-ahead reads 0.

sp_helpindex we can check what indexes Query 2:

are defined on a table: (4 row(s) affected)
Table 'Client'. Scan count 1, logical reads
19458, physical reads 0, read-ahead reads 0,
sp_helpindex Client lob logical reads 0, lob physical reads 0,
lob read-ahead reads 0.
In figure 4, we can see that we have 2
indexes defined on our Client table,
PK_Client index is generated
automatically when we specified the
primary key for the table.

Fig. 4 Current indexes on table Client

To understand how index seek and index

scan works, the execution plan is turned
on and the following queries are
executed:

Query 1:
select * from Client where Fig. 5 Execution plan of Query 1 and
LastName = 'LastName4' Query 2
Query 2: An index scan either clustered or
select * from Client where
FirstName = 'FirstName4' nonclustered will do a complete scan in a
18 Increasing Database Performance using Indexes

clustered or nonclustered index. Neither Adding indexes (both clustered and

index uses the b-tree structure of the nonclusterd) will increase the amount of
index but only reads the leaf pages in execution time that the INSERT, UPDATE
order using each pages reference to the and DELETE statement take, as the data has
next in the chain. to be updated in the table an also in each
An index seek is a seek through the b-tree index;
structure of a nonclustered index, from Columns of the IMAGE data type cannot be
the root down to the leaf. A clustered indexed using normal indexes;
index seek is looking in the structure of a
clustered index from the root down to the Clustered Indexes
leaf. SQL Server supports only one clustered
Index seek is preferred for the highly index for each database table. This index
selective queries, when the query is should be the most common column that is
returning a fewer number of rows, less in the WHERE clause for queries against
than 15% of total rows in the table. this table. In most cases the search is by
If there is an index on a table and if the primary key and this index is automatically
query is fetching a large amount of data, created.
more than 70% of total rows in a table, The reordering of the data occurs every time
then the database engine will scan all the the index changes;
data pages to retrieve the data rows. Reorders the way records are physically
stored;
5 Clustered indexes compared to
nonclustered indexs Nonclustered Indexes
Clustered and Non Clustered indexes Nonclustered indexes, also called indexes
have the following common are the normal indexes that are created on
characteristics as presented in [5]: your tables. SQL Server supports 999
Both clustered and nonclustered indexes nonclustered indexes per table.
are created based on one or more Each nonclustered index can contain upto
columns. The columns are put in the 1023 included columns. Columns of the
index in the order you specify them in the TEXT, NTEXT and IMAGE data types
CREATE INDEX statement. They are cannot be included either.
also sorted in this order as well. Indexes Nonclustered indexes are not copies of the
are first sorted on the first column in the table but a sorting of the columns that reffer
index, then any duplicates of the first to the data pages in the clustered index.
column and sorted by the second column, Because of this, the clustered index affects
etc; all other indexes.
Neither clustered or nonclustered indexes There are two modes for the nonclustered
will guarantee the sort order of the data index: non-unique and unique.The non-
when it is being returned to you. If the unique type specifies that the index allows
order of the data matters to you, you identical rows to be inserted, compared to
should always sort the data with the the unique type which does not allow any
ORDER BY clause in your select identical rows.
statement. As presented in [6], the nonclustered index
Both clustered indexes and nonclustered does not re-order the actual table data. If the
indexes take up additional disk space. clustered index is missing, then the
The amount of space that they require nonclustered index will point to the actual
will depend on the columns in the index, data in table.
and the number of rows in the table. The Logical order of the index is not identical
clustered index will also grow as you add with the physical order of the rows stored on
columns to the table; disk.
Database Systems Journal vol. II, no. 2/2011 19

Nonclustered indexes should be used for new data is added to the index. In our
queries that return small amount of data example we will add 5 and automatically a
and to columns used in WHERE clauses new page will be created and the 7 and 8
that return exact matches. Large result will be moved to the new page in order to
sets are reading more tables pages make room for the 5 on the original page.
anyway so they will not benefit from a Due to this, the index will be out of logical
nonclustered index. order as seen in figure 7.

6 Index fragmentation
When the user performs operations like
INSERT, UPDATE or DELETE on the Fig. 7 New index structure
database, table fragmentation may occur.
Also when changes affect the data that is This type of fragmentation will affect the
covered by the index, then index performance of queries that do not have
fragmentation occurs and the information specific searches or that return unordered
in the index is scattered over the result sets, but will affect queries that
database. Due to this, when a query is returned ordered sets. An example of an
performed against a heavy fragmented ordered result set is a query that is returning
table, the operation will take longer time. everything from page 4 to 12. This query
Index fragmentation comes in two has to complete an extra page switch in
different forms: external fragmentation order to return the 7 and 8 pages. If the
and internal fragmentation. In each of fragmentation affects tables with hundreds
these forms, the pages within the index of pages the amount of extra page switches
are used inefficiently. External will be significantly greater.
fragmentation means that the logical
order of the pages are wrong and internal In order to determine the level of
fragmentation represents that the amount fragmentation the following command can
of data stored within each page is less be used:
than the data page.
Each leaf page of an index must be in a DBCC SHOWCONTIG (TableName)
logical order otherwise external
fragmentation occurs. When an index is The syntax of this command is:
created, the index keys are sorted in a
DBCC SHOWCONTIG
logical order on a set of index pages. [({ table_name
Each time new data is inserted in the | table_id
index, there could be the possibility that | view_name
the new keys are inserted between | view_id }
existing keys. This may lead to the [ , index_name | index_id ]
)
creation of new index pages to ]
accommodate the existing keys that were [ WITH { ALL_INDEXES
moved so that new keys can be inserted | FAST [ , ALL_INDEXES ]
in correct order. | TABLERESULTS [ , { ALL_INDEXES } ]
[ , { FAST | ALL_LEVELS } ]
Lets assume the current index structure
}
presented in figure 6. ]

After running this command on a table or

view, the results are presented below:
Fig. 6 Current index structure
DBCC SHOWCONTIG scanning 'Person' table...
Table: 'Person' (839842950); index ID: 1,
When an INSERT statement is executed, database ID: 5
20 Increasing Database Performance using Indexes

TABLE level scan performed.

- Pages Scanned...................: 53600
- Extents Scanned.................: 6712 The fragmentation can be reduced and the
- Extent Switches.................: 8579
- Avg. Pages per Extent...........: 8.0
performance improved by using the
- Scan Density [Best Count:Actual following methods:
Count].......: 78.09% [6700:8580]
- Logical Scan Fragmentation .....: 5.31%
Dropping and recreating the index;
- Extent Scan Fragmentation ......: 43.19% Rebuilding the index using the DBCC
- Avg. Bytes Free per Page........: 753.2
- Avg. Page Density (full)........: 90.69% DBREINDEX statement;
DBCC execution completed. If DBCC printed Defragmenting an index by using the
error messages, contact your system
administrator. DBCC INDEXDEFRAG statement.

The command returns the number of Dropping and rebuilding an index has the
pages scanned, the number of extents advantage of completely rebuilding an index
scanned the number of times the DBCC and does reorder the index pages,
statement moved from one extent to compacting the pages, and dropping any
another while parsing the pages of the unneeded pages. This operation should be
table or index, the average number of done on indexes that show high levels of
pages per extent, the scan density. both internal and external fragmentation.

Pages Scanned: If the number of rows DROP INDEX and CREATE INDEX
contained in the table or index divided by
the approximate row size is significantly Rebuilding the index can reduce
greater than the number of pages scanned fragmentation and it is done by using the
then there could be internal fragmentation following statement:
of the index.
Extents Scanned: Take the number of DBCC DBREINDEX
pages scanned and divide that number by
8, rounded to the next highest interval. This operation is similar to dropping and
This figure should match the number of creating the index, except that it will rebuild
extents scanned returned by DBCC the index physically allowing the SQL
SHOWCONTIG. If the number returned Server to assign new pages to the index and
by DBCC SHOWCONTIG is higher, reduce both internal and external
then you have some external fragmentation. This statement also recreates
fragmentation. The seriousness of the indexes with existing constraints.
fragmentation depends on just how high Defragmenting an index by using the DBCC
the shown value is from the estimated INDEXDEFRAG statement reduces the
value. external fragmentation by rearranging the
Extent Switches: This number should be existing leaf pages of an index to the logical
equal to (Extents Scanned 1). Higher order of the index key and internal
numbers indicate external fragmentation. fragmentation by compacting the rows
Extent Scan Fragmentation: Shows any within index pages then discarding
gaps between extents. This percentage unnecessary pages. The time needed to
should be 0% and higher percentages execute this statement is longer than
indicate external fragmentation. recreating an index if the amount of
fragmentation is high. DBCC
By analyzing the results provided by INDEXDEFRAG can defragment an index
DBCC SHOWCINTIG on our Person while other processes are accessing the
table we can see that the number of extent index, eliminating the blocking restrictions.
switches is much greater than the number
of extents scanned. In this case there is 7 Conclusions
external fragmentation.
Database Systems Journal vol. II, no. 2/2011 21

Using indexes on the database improves Contention using

the performance of the whole system. sys.dm_db_index_operational_stats
These indexes are of different type and
should be used in an intelligent way in The database performance can be improved
order to achieve the whished behavior. by reducing the table or index
Clustered indexes should be used for fragmentation. This is achieved by dropping
queries that return a large amount of data. and recreating the index, rebuild the index
The clustered index is recommended to by using DBCC DBREINDEX statement or
be created on the primary key of the by defragmenting the index using DBCC
table. For all other columns nonclustered INDEXDEFRAG statement.
indexes should be created.
A noncluster index is better to be used 8 Acknowledgment
when running queries that return a This work was cofinaced from the European
smaller amount of data. By using this Social Fund through Sectoral Operational
type of indexes large amount of data will Programme Human Resources Development
have to read in lot of data pages, and the 2007-2013, project number
performance of the system will decrease. POSDRU/107/1.5/S/77213 Ph.D. for a
Choosing the number and type of indexes career in interdisciplinary economic
can dramatically affect the performance research at the European standards.
and can mean the difference between data
being retrieved in seconds, with few disk References
I/Os or minutes, even hours, with many [1] G. Fritchey, S. Dam, SQL Server 2008
disk I/Os. Choosing the optimum number Query Performance Tuning Distilled,
of indexes to support the critical queries Apress, 2009, ISBN 978-1-4302-1903-3,
is therefore an extremely important task. 560 pages
Before creating a new index one must [2] K. England, Microsoft SQL Server 2000
make sure that there arent any unused Performance Optimisation and Tuning
indexes. Also remove the minimally Handbook, Digital Press, 2001, ISBN
useful or redundant/duplicate indexes like 978-1555582418, 320 pages
subsets of other indexes. [3] A. Mocanu, M. Velicanu, Building a
Combine existing indexes to create a Spatial Database for Romanian
consolidated index: Archaeological Sites, Database Systems
Journal, Vol. II, ISSN: 2069 323, p. 3-
Index1: 12.
(LastName, FirstName) INCLUDE [4] http://www.sql-server-
(phone) performance.com/2010/logical-reads/
[5] http://itknowledgeexchange.techtarget.
Index2: com/sql-server/back-to-basics-clustered-
(LastName, FirstName, MiddleName)
INCLUDE (PIN) vs-nonclustered-indexes-whats-the-
difference/
Combined Index: [6] http://www.devtoolshed.com/content/clu
(LastName, FirstName, MiddleName) stered-index-vs-non-clustered-index-sql-
INCLUDE (phone, PIN) server
[7] http://blogs.msdn.com/b/craigfr/ archiar/
Verify the health of the existing indexes 2006/06/30/652639.aspx
periodically for: [8] C. Churcher, Beginning Database
Splits using Design. From novice to professional,
sys.dm_db_index_operational_stats Appress, 2007, ISBN 1-59059- 69- 9,
Fragmentation using 267 pages
sys.dm_db_index_physical_stats
22 Increasing Database Performance using Indexes

Cecilia CIOLOCA has graduated the Faculty of Economic

Cybernetics, Statistics and Informatics from the Bucharest Academy
of Economic Studies in 2008. She is currently conducting doctoral research in Economic
Informatics at the Academy of Economic Studies. She is experienced in software
development using open source technologies. She has successfully completed several projects
using various programming languages and open source frameworks. She is proficient in using
Java Enterprise Edition.

Mihai GEORGESCU has graduated the Faculty of Electronics,

Telecommunications and Information Technology Politehnica University Bucharest in 2005
and also completed a master program at the Faculty of Economic Cybernetics, Statistics and
Informatics from the Bucharest Academy of Economic Studies in 2007. He has experience in
the development of software products using various programming languages like C/C++, C#
both Windows Forms and Web.