SQL

Server
2012

Data Management Using

Microsoft SQL Server

Session: 11

Session: 1 Indexes

Introduction to the Web

 SQL
Server
2012
Objectives

• Define and explain indexes

• Describe the performance of indexes
• Explain clustered indexes
• Explain nonclustered indexes
• Explain partitioning of data
• Explain the steps to display query performance data using
indexes

© Aptech Ltd. Indexes/ Session 11 2

 SQL
Server
2012
Overview of Data Storage

• SQL Server 2012 stores data in storage units known as 8 KB -data-

pages.
• A set of eight contiguous data pages is referred to as an extent.
• A page begins with a 96-byte header, which stores system information
about the page.
• This information includes the following:
Page number

Page type

Amount of free space on the page

Allocation unit ID of the object to

which the page is allocated

© Aptech Ltd. Indexes/ Session 11 3

 SQL
Server
2012
Data Files

• All input and output operations in the database are performed at

the page level.
• SQL Server 2012 stores data pages in files: Primary, Secondary data
file and Log file.
• The space allotted to a data file is divided into sequentially
numbered data pages.
• The numbering starts from zero as shown in the following figure: 

© Aptech Ltd. Indexes/ Session 11 4

 SQL
Server
2012
Indexes 1-2

• In a table, records are stored in the order in which they are

entered  Data is unsorted.
• When data is to be retrieved, the entire table needs to be
scanned  slows down the query retrieval process
• To speed up query retrieval, indexes need to be created.

© Aptech Ltd. Indexes/ Session 11 5

 SQL
Server
2012
Indexes 2-2
• Indexes are automatically created when PRIMARY KEY and UNIQUE
constraints are defined on a table.
• Indexes reduce disk I/O operations and consume fewer system resources.

• Syntax:
CREATE INDEX <index_name> ON <table> (<column>)

• Example: CREATE INDEX IX_Country ON Customer(Country);

• Facts about indexes:

increase the speed of queries that join tables or perform
sorting operations.

implement the uniqueness of rows if defined when you

create an index.

are created and maintained in ascending or descending

order.

© Aptech Ltd. Indexes/ Session 11 6

 SQL
Server
2012
Index B-Tree Structure
• Data in the database can be stored either in a sorted manner or at random.
• If data is stored in a sorted manner  clustered structure.
• If it is stored at random  heap structure.
• In SQL Server, all indexes are structured in the form of B-Trees.
• B-Tree structure can be visualized as an inverted tree, including different
nodes :
 Root node : index page with pointers pointing to index pages at the first
intermediate level.
 Intermediate nodes: index pages with pointers pointing either to index pages at
the next intermediate level or to index or data pages at the leaf level.
 Leaf nodes: either data pages or index pages that point to data pages

© Aptech Ltd. Indexes/ Session 11 7

 SQL
Server
2012
Heap Structures

• In a heap structure, the data pages and records are not arranged in
sorted order.
• The only connection between the data pages is the information
recorded in the Index Allocation Map (IAM) pages.
• IAM pages are used to scan through a heap structure.
• IAM pages map extents that are used
by an allocation unit in a part of a
database file.
• A heap can be read by scanning the IAM
pages to look for the extents that contain
the pages for that heap.

© Aptech Ltd. Indexes/ Session 11 8

 SQL
Server
2012
Partitioning of Heap Structures

• A table can be logically divided into smaller groups of rows.

• This division is referred to as partitioning  maintenance efficiently
• By default, a table has a single partition.
• When partitions are created in a table with a heap structure, each
partition will contain data in an individual heap structure.
• For example, if a heap has three partitions, then there are three
heap structures present, one in each partition

© Aptech Ltd. Indexes/ Session 11 9

 SQL
Server
2012
Clustered Index Structures

• A clustered index causes records to be physically stored in a sorted or

sequential order.
• A clustered index determines the actual order in which data is stored
in the database. Hence, only one clustered index can be created in a
table.
• Uniqueness of a value
in a clustered index is
maintained explicitly
using the UNIQUE
keyword or implicitly
using an internal unique

© Aptech Ltd. Indexes/ Session 11 10

 SQL
Server
2012
Creating Clustered Index
• There is only one clustered index in a table, on column(s) without
duplicate values.
• Syntax:
CREATE CLUSTERED INDEX index_name ON <table> (column_list)

CREATE CLUSTERED INDEX IX_CustID ON Customer(CustID)

• A clustered index is automatically created when a primary key is

defined on the table.
• In a table without a primary key, clustered index should ideally be
defined on:
• Key columns that are searched on extensively.
• Columns used in queries that return large resultsets.
• Columns having unique data.
• Columns used in table join.

© Aptech Ltd. Indexes/ Session 11 11

 SQL
Server
2012
Nonclustered Index Structures 1-2
• Nonclustered index is the default index.
• Each index row in the nonclustered index contains a nonclustered key value
and a row locator.
• This row locator points to the data row corresponding to the key value in
the table.

CREATE [NONCLUSTERED] INDEX <idx_name> ON <table>(column_list)

• example:

CREATE INDEX IX_State ON Customer(State)

GO

© Aptech Ltd. Indexes/ Session 11 12

 SQL
Server
2012
Nonclustered Index Structures 2-2
 Nonclustered indexes have a B-Tree structure similar to clustered indexes but
with the following differences

The data rows of the table are not physically stored in the order defined
by their nonclustered keys.

In a nonclustered index structure, the leaf level contains index rows.

 Nonclustered indexes are useful when you require multiple ways to search data.
 Guidelines to be considered before creating a nonclustered index :

When a clustered index is re-created or the DROP_EXISTING option is

used, SQL Server rebuilds the existing nonclustered indexes.

A table can have up to 999 nonclustered indexes.

Clustered index should be created before nonclustered indexes.

© Aptech Ltd. Indexes/ Session 11 13

 SQL
Server
2012
Column Store Index 1-4

• Column Store Index is a new feature in SQL Server 2012.

• It enhances performance of data warehouse queries extensively.
• The regular indexes and heaps stored data in B-Tree structure
row-wise, but the column store index stores column-wise data .
• Since the data transfer rate is slow in database servers, so column
store index uses compression aggressively to reduce the disk I/O
needed to serve the query request

© Aptech Ltd. Indexes/ Session 11 14

 SQL
Server
2012
Column Store Index 2-4

• For example, if there is a table

with ten columns (C1 to C10),
the data of all the ten columns
from each row gets stored
together continuously on the
same page as shown in the
aside figure.

© Aptech Ltd. Indexes/ Session 11 15

 SQL
Server
2012
Column Store Index 3-4
• When column store index is
created, the data is stored
column-wise, which means
data of each individual
column from each rows is
stored together on same
page.
• For example, the data of
column C1 of all the rows
gets stored together on one
page and the data for
column C2 of all the rows
gets stored on another page
and so on as shown in the
aside figure

© Aptech Ltd. Indexes/ Session 11 16

 SQL
Server
2012
Column Store Index 4-4

CREATE [ NONCLUSTERED ] COLUMNSTORE INDEX index_name ON <object>

( column list )
[ WITH ( <column_index_option> [ ,...n ] ) ]

• example:
CREATE COLUMNSTORE INDEX [csindx_ResellerSales] ON
[ResellerSalesPtnd]
(
[ProductKey], [OrderDateKey], [DueDateKey],
[ShipDateKey], [CustomerKey], [EmployeeKey],
[PromotionKey], [CurrencyKey], [SalesTerritoryKey],
[SalesOrderNumber], [SalesOrderLineNumber],
[RevisionNumber], [OrderQuantity], [UnitPrice],
[ExtendedAmount], [UnitPriceDiscountPct], [DiscountAmount],
[ProductStandardCost],
[TotalProductCost], [SalesAmount], [TaxAmt],
[Freight],[ CarrierTrackingNumber], [CustomerPONumber],
[OrderDate], [DueDate], [ShipDate]
);

© Aptech Ltd. Indexes/ Session 11 17

 SQL
Server
2012
Dropping an Index 1-2

• While dropping all indexes on a table, first drop the nonclustered

indexes and then, the clustered index.
• SQL Server 2012 can drop the clustered index and move the heap
(unordered table) into another filegroup or a partition scheme
using the MOVE TO option.
• MOVE TO option is not valid for nonclustered indexes.
• The partition scheme or filegroup specified in the MOVE TO clause
must already exist.
• The table will be located in the same partition scheme or filegroup
of the dropped clustered index.

© Aptech Ltd. Indexes/ Session 11 18

 SQL
Server
2012
Dropping an Index 2-2

DROP INDEX <index_name> ON <table_name>

[ WITH ( MOVE TO { <partition_scheme_name> ( <column_name> )
| <filegroup_name>
| 'default'
})
]

• example:

DROP INDEX IX_SuppID ON Supplier_Details

WITH ( MOVE TO 'default‘ )

DROP INDEX IX_SuppID ON Supplier_Details

WITH ( MOVE TO FGCountry )

© Aptech Ltd. Indexes/ Session 11 19

 SQL
Server
2012
Clustered vs. Nonclustered Indexes

Clustered Indexes Nonclustered Indexes

Used for queries that return Used for queries that do not return
large resultsets large resultsets

Only one clustered index can be Multiple nonclustered indexes can be

created on a table created on a table

The data is stored in a sorted The data is not stored in a sorted

manner on the clustered key manner on the nonclustered key

The leaf nodes contain the data

The leaf nodes contain index pages
pages

© Aptech Ltd. Indexes/ Session 11 20

 SQL
Server
2012
Creating Unique Indexes

• A unique index can be created on a column that does not have any
duplicate values  ensures entity integrity.
• If a table definition has a PRIMARY KEY or a column with a UNIQUE
constraint, SQL Server automatically creates a unique index when you
execute the CREATE TABLE statement.

CREATE UNIQUE INDEX <index_name> ON <table>(<column_name>)

• example:

CREATE UNIQUE INDEX IX_CustID ON Customer_Details(CustID)

© Aptech Ltd. Indexes/ Session 11 21

 SQL
Server
2012
Computed Columns

• A computed column is a virtual column in a table whose value (not

stored in the table) is calculated at run-time.
• The expression consists of a non-computed column name associated
with a constant, a function, or a variable using arithmetical or logical
operators.
• Syntax CREATE TABLE <table_name>
([<column_name> AS <computed_column_exp>])

• Example
CREATE TABLE Calc_Area
( Length int, Breadth int, Area AS Length*Breadth )
GO

© Aptech Ltd. Indexes/ Session 11 22

 SQL
Server
2012
Creating Index on Computed Columns

• An index can be created on a computed column if the column is marked

PERSISTED.
• This ensures that the Database Engine stores computed values in the table.
• These values are updated when any other columns on which the computed
column depends are updated.

CREATE INDEX <index_name> ON <table>

(<computed_column_name>)

© Aptech Ltd. Indexes/ Session 11 23

 SQL
Server
2012
XML Indexes
• The xml data type is used to store XML documents and fragments
• An XML fragment is an XML instance that has a single top-level element
missing.
• Due to the large size of XML columns, queries that search within these
columns can be slow.
• To speed up these queries , create an XML index on each column.
• XML indexes can be created on a table only if there is a clustered index
based on the primary key of the table.
• This primary key cannot exceed 15 columns.
• An XML index can be a clustered or a nonclustered index.
• Each table can have up to 249 XML indexes.
• The different types of XML indexes are as follows: Primary, Secondary and
Selective XML index

© Aptech Ltd. Indexes/ Session 11 24

 SQL
Server
2012
Types of XML Indexes 1-2

Primary XML Indexes

It is a special index created on each XML column to speed up these queries.

CREATE PRIMARY XML INDEX index_name ON <table_name> (column_name)

 Example
CREATE PRIMARY XML INDEX XML_Product ON ProductModel(CatalogDesc);

Secondary XML Indexes

can only be created on columns that already have a primary XML index, uses for :
• Searching for values anywhere in the XML document.
• Retrieving particular object properties from within an XML document.

 Example CREATE XML INDEX IXML_Product_Path ON ProductModel(CatalogDesc)

USING XML INDEX XML_Product FOR PATH ;
GO

© Aptech Ltd. Indexes/ Session 11 25

 SQL
Server
2012
Types of XML Indexes 2-2

Selective XML Indexes (SXI)

 This is a new type of XML index introduced by SQL Server 2012.

 The index is to improve querying performance over the data stored as
XML, and improves scalability by reducing storage costs of the index.

 Following code snippet demonstrates how to create a Selective XML index on

the BookDetails column in the BooksBilling table:

CREATE SELECTIVE XML INDEX SXI_index ON BooksBilling ( BookDetails )

FOR
(
pathTitle = '/book/title/text()' AS XQUERY 'xs:string',
pathAuthors = '/book/authors' AS XQUERY 'node()',
pathId = '/book/id' AS SQL NVARCHAR(100)
)
GO

© Aptech Ltd. Indexes/ Session 11 26

 SQL
Server
2012
Modifying an XML Index

An XML index, primary or secondary, can be modified using the ALTER

INDEX statement.

ALTER INDEX <xml_index_name> ON <table_name> REBUILD

Following code snippet rebuilds the primary XML index

PXML_DocumentStore created on the XMLDocument table:

ALTER INDEX PXML_DocumentStore ON XMLDocument REBUILD

© Aptech Ltd. Indexes/ Session 11 27

 SQL
Server
2012
Removing an XML Index

Syntax
:

DROP INDEX <xml_index_name> ON <table_name>

 For example:

DROP INDEX PXML_DocumentStore ON XMLDocument

© Aptech Ltd. Indexes/ Session 11 28

 SQL
Server
2012
Allocation Units
• A heap or a clustered index structure contains data pages in one or more
allocation units.
• An allocation unit is a collection of pages and is used to manage data based
on their page type.
• The types of allocation units are as follows:

• It is used to manage data or index rows that contain all

IN_ROW_DATA
types of data except large object (LOB) data.

• It is used to manage large object data, such as:

LOB_DATA
varbinary(max), varchar(max), and xml.

• It is used to manage data of variable length: varchar,

ROW_OVERFLOW_DATA
nvarchar, varbinary, or sql_variant columns.

© Aptech Ltd. Indexes/ Session 11 29

 SQL
Server
2012
Partitioning

• Partitioning divides data into subsets.

• This makes large tables or indexes more manageable.
• Partitioning enables you to access data quickly and efficiently.
• Maintenance operations on subsets of data are performed more
efficiently because they target only the required subset of data
instead of the entire table.
• By default, a table or an index has only one partition that contains
all the data or index pages.

© Aptech Ltd. Indexes/ Session 11 30

 SQL
Server
2012
The [Link] View

• is a system view that contains the complete information about the different
partitions of all the tables and indexes in the database.
• Following table shows the different columns of the [Link] view:

Column Name Data Type Description

partition_id bigint Contains the id of the partition and is unique within

a database.
Contains the id of the object to which the partition
object_id int belongs.
Contains the id of the index to which the partition
index_id int
belongs.
Contains the partition number within the index or
partition_number int
heap.
Contains the id of the data heap or B-Tree that
hobt_id bigint
contains the rows for the partition.

rows bigint States the approximate number of rows in the

partition.
© Aptech Ltd. Indexes/ Session 11 31
 SQL
Server
2012
The index_id column

• The index_id column contains the id of the index to which the

partition belongs.
• Following are the various values of the index_id column:

The index_id value for a heap is 0.

The index_id value for a clustered index is 1.

The index_id value for a nonclustered index is

greater than 1.

The index_id value for large objects is greater

than 250.

© Aptech Ltd. Indexes/ Session 11 32

 SQL
Server
2012
Cursors 1-5
• Is a DB Object that used to retrieve data as one row at a time from a resultset
• Is used when records in a database table need to be updated one row at a time.
• Types of Cursors: Static, Dynamic, Forward only and Keyset Driven

• help to populate the resultset when the cursor is created

Static and the query result is cached. This is the slowest of
Cursor all the cursors.
s • can move/scroll in both backward and forward directions.
• cannot be updated or deleted.

Dynami
• allow to view the procedures of insertion, updation, and
c deletion when the cursor is open.
Cursor • is one of the most sensitive cursor and is scrollable.
s

Forwar • support updation and deletion of data.

• is the fastest cursor though it does not support backward
d Only scrolling.
Cursor • The three types of forward cursors are FORWARD_ONLY
s KEYSET, FORWARD_ONLY STATIC, and FAST_FORWARD.

© Aptech Ltd. Indexes/ Session 11 33

 SQL
Server
2012
Cursors 2-5

• create a set of unique identifiers as keys in a keyset that are used

to control the cursor.
Keyset Driven • is also a sensitive cursor that can update and delete data.
Cursors • The keyset is dependent on all the rows that qualify the SELECT
statement at the time of opening the cursor.

Syntax
:
DECLARE cursor_name CURSOR [ LOCAL | GLOBAL ]
[ FORWARD_ONLY | SCROLL ]
[ STATIC | KEYSET | DYNAMIC | FAST_FORWARD ]
[ READ_ONLY | SCROLL_LOCKS | OPTIMISTIC ]
[ TYPE_WARNING ]
FOR select_statement
[ FOR UPDATE [ OF column_name [ ,...n ] ] ]
[;]

where,
cursor_name: is the name of the cursor defined, cursor_name must comply
to the rules for identifiers.

© Aptech Ltd. Indexes/ Session 11 34

 SQL
Server
2012
Cursors 3-5

LOCAL: specifies that the cursor can be used locally to the batch, stored procedure, or
trigger in which the cursor was created.
GLOBAL: specifies that the cursor can be used globally to the connection.
FORWARD_ONLY: specifies that the cursor can only be scrolled from the first to the
last row.
STATIC: defines a cursor that makes a temporary copy of the data to be used by the
cursor.
KEYSET: specifies that the membership and order of rows in the cursor are fixed
when the cursor is opened.
DYNAMIC: defines a cursor that reflects all data changes made to the rows in its
resultset as you scroll around the cursor.
FAST_FORWARD: specifies a FORWARD_ONLY, READ_ONLY cursor with
performance optimizations enabled.
READ_ONLY: prevents updates made through this cursor.
SCROLL_LOCKS: specifies that positioned updates or deletes made through the
cursor are guaranteed to succeed.

© Aptech Ltd. Indexes/ Session 11 35

 SQL
Server
2012
Cursors 4-5

 Following code snippet creates an Employee table in SampleDB database:

USE SampleDB
CREATE TABLE Employee (
EmpID int PRIMARY KEY,
EmpName varchar (50) NOT NULL,
Salary int NOT NULL,
Address varchar (200) NOT NULL,
)
GO

INSERT INTO Employee(EmpID,EmpName,Salary,Address) VALUES

(1,'Derek',12000,'Housten')
(2,'David',25000,'Texas')
(3,'Alan',22000,'New York')
(4,'Mathew',22000,'las Vegas')
(5,'Joseph',28000,'Chicago')
GO

SELECT * FROM Employee

© Aptech Ltd. Indexes/ Session 11 36

 SQL
Server
2012
Cursors 5-5
 Example SET NOCOUNT ON
DECLARE @Id int , @name varchar(50), @salary int

DECLARE cur_emp CURSOR STATIC FOR

SELECT EmpID,EmpName,Salary from Employee

OPEN cur_emp
IF @@CURSOR_ROWS > 0
BEGIN
/*Rows are fetched from the cursor one by one */
FETCH NEXT FROM cur_emp INTO @Id,@name,@salary
WHILE @@Fetch_status = 0
BEGIN
PRINT 'ID : '+ convert(varchar(20),@Id)+', Name :
'+@name+ ', Salary : '+convert(varchar(20),@salary)
FETCH NEXT FROM cur_emp INTO @Id,@name,@salary
END
END
CLOSE cur_emp --close the cursor explicitly

/*Delete the cursor definition and release all the system

resources */
DEALLOCATE cur_emp
SET NOCOUNT OFF

© Aptech Ltd. Indexes/ Session 11 37

 SQL
Server
2012
Summary

• Indexes increase the speed of the querying process by providing quick access
to rows or columns in a data table.
• SQL Server 2012 stores data in storage units known as data pages.
• All input and output operations in a database are performed at the page
level.
• SQL Server uses catalog views to find rows when an index is not created on a
table.
• A clustered index causes records to be physically stored in a sorted or
sequential order.
• A nonclustered index is defined on a table that has data either in a clustered
structure or a heap.
• XML indexes can speed up queries on tables that have XML data.
• Column Store Index enhances performance of data warehouse queries
extensively.

© Aptech Ltd. Indexes/ Session 11 38