How to calc storage prarams on INDEXES?

Question

Can anyone recommend any good rules of thumb (or associated reading) on how to calculate
"good" values for index tablespace
allocations? Fox example, if I know the number and datatypes of my keys and the anticipated number of rows, can I workout
a viable INITIAL EXTENT value?

Answer 1

Hi,
Sizing of Indexes
First we will have to find out how much data fits in to one block.
The size of the block header is approximately 161 bytes.
If your block size is 2k then this leaves
2048-161 = 1887 bytes available
Next factor is the pctfree setting.
While calculating an Indexs size we will have to keep pctfree in mind and
deduct that from the total size to find out the actual available size.
If you use a pctfree of 10, then
1887*(pctfree/100) = 1887*0.1=189 (rounded up)
Of the available free space, 189 bytes will be deducted.
1887-189=1698 (bytes available)
Of the 2048 bytes in the block, 1698 bytes are available for storing index
entries.
The next step is to calculate the space used per index entry.
To estimate the space used per index entry, you need to estimate the average
row length.
The average row length is the total of the average length of each value in a
row; for indexes you only need to be concerned about the indexed columns.
For example consider an index containing two columns, all of which are
varchar2 (10). The average row length cannot exceed 20.
Its actual length depends on the data that will be stored there.
If the sample data is available, then the VSIZE function can be used to
determine the average row length.
SELECT AVG (NVL (VSIZE (COLUMN1), 0))+
AVG (NVL (VSIZE (COLUMN2), 0)) AVG_ROW_LENGTH
FROM TABLENAME;
For example, in the sample two-columned index, assume that the average row
length for the indexed columns is 16 bytes. To that total add 1 byte for
each column in the index, for a total of 18 bytes per row. If the index has
columns that contain data that is more than 127 characters long, add an
extra byte for each such column.
Finally, add 8 bytes for the index entry header.
Space used per row = avg_row_length
+8 (for the header)
+ Number of columns
+ Number of long columns (250+)
Space used per row = 16
+8
+ 2
+ 0
=26 bytes per index entry
If the index is a unique index, add I to this total.
26 + 1 = 27 bytes per row
Given 1698 bytes available and 27 bytes per row, you can fit 62 index
entries in a block:
Entries per block = TRUNC (1698 free bytes/27 bytes per entry)
= 62 entries per block.
Since you can fit 62 entries in one block of 2k size you can estimate the
size of the index accordingly.
Creation of a different tablespace for Indexes
(check if you already have a tablespace for this purpose by querying the
data dictionary table dba_tablespaces )
create tablespace indexes
datafile 'd:\oracle\oradata\ocp1\index01.dbf' size 25M
default storage(
initial 250k
next 250k
maxextents unlimited
pctincrease 0
If you are creating a new index then use the following command
Alter table <table_name>
Add constraint <constraint_name> unique (column_name)
Using index tablespace indexes;
If you already have an index and you want to transfer it to the tablespace
created for this purpose then use the following command
Alter index <index_name> rebuild
Tablespace indexes
Storage (initial 2M next 2M pctincrease 0);
Rollback Segment Information:
The following data dictionary views give information about the rollback
segments.
DBA_ROLLBACK_SEGS
GV$ROLLSTAT
V$ROLLNAME
V$ROLLSTAT
with regards,
Boby Jose Thekkanath,
Dharma Computers(P) Ltd.
Bangalore-India.
www.dharma.com