Monday, 7 September 2009

Index Selectivity Analysis

Why does Oracle sometimes not use an index when executing a SQL query? Even when the index includes most of the columns from a table explicitly referenced in the query? The obvious answer is that using the index does not produce a lower cost than other access methods, such as a full table scan. The Optimizer has calculated that the number of disk I/Os needed to use the index (depth of index plus matching leaf blocks) and then get the data blocks (number of matching rows) would be greater than the number of disk I/Os needed to do a full table scan with multi-block reads.

In a case like this, such an index will almost never be used by Oracle even though the index includes columns directly referenced in the WHERE clause of a query. This is because the number of estimated disk I/Os to use it will always be greater than the number of disk I/Os to do a full table scan. There might be exceptions in cases where the data is very skewed and you have a histogram on the columns in the index, and you are selecting a value with a low occurrence count. But generally such an index is unlikely to be used by any queries you run.

Which raises the question, how can we find out which indexes in our database are selective enough to be used by a query before we actually run those queries? Or conversely, which indexes are not selective enough given the data in the database and will never be used? It is a bit too late to find out when we are running a query and Oracle is doing a full table scan and taking a long time to do it. Of course we could do an EXPLAIN PLAN of the query beforehand, but execution plans can change over time dependent on the volumes of data in a table, and the distribution of data values.

We would like to have a query that we can run on a complete database, and which will tell us which indexes are not selective given the actual data in the tables. This would flag weak indexes to us, regardless of which queries might be running i.e. indexes that are unlikely to be chosen by the Optimizer even if all columns in them are referenced in the query.

How would such a query work? Well, we know how the Optimizer costs the different access methods to data in a table (see previous posts on Full Table Scans and Index Scans). We can calculate each of these for a table and an index, and see if the table scan cost is lower than the index access cost. In fact, using a bit of maths we can manipulate the formula for these two costs together in a way that results in a more direct comparison. If the maths bit is too much for you then just skip ahead to the final formula followed by the SQL to run it.

The costs of each type of access are:
  • FTS Cost = (Blocks * mreadtim) / (MBRC * sreadtim)
  • Index Cost = Levels + (Leaf Blocks + Clustering Factor) * Filter Factor
And an index will be ignored when:
  • Index Cost > Full Table Scan Cost
Assuming that the table is large, then the number of blocks in the index will be far greater than the depth or number of levels in the index tree, so we can ignore this. This gives the relationship between the two that an index will be ignored when (approximately):
  • (Leaf Blocks + Clustering Factor) * Filter Factor > (Blocks * mreadtim) / (MBRC * sreadtim)
Dividing both sides gives:
  • Filter Factor > (Blocks * mreadtim) / (MBRC * sreadtim * (Leaf Blocks + Clustering Factor))
Now when there is no histogram on the columns or no data skew then the Filter Factor will be the inverse of the Number of Distinct Values or Keys i.e.
  • Filter Factor = 1 / Distinct Keys
Inverting both sides, and the relationship too gives us
  • Distinct Keys < (MBRC * sreadtim * (Leaf Blocks + Clustering Factor)) / (Blocks * mreadtim)
All of these values are stored in the Data Dictionary of the database in one place or another. So we can write a single SQL query that can calculate both sides of the comparison directly from the database itself. Note that this assumes that the statistics on your tables and indexes are up to date, and reflect the true data distributions in the tables.

To make some things easier we can group together values that are table and index independent, finally giving us that for the index to be ignored the following must be true:
  • Distinct Keys < (MBRC * sreadtim / mreadtim) * (Leaf Blocks + Clustering Factor) / Blocks
We can calculate the expression "(MBRC * sreadtim / mreadtim)" once, and then use this value with the other values on each index on each table in a database. We can then list all the indexes that fail the test i.e. indexes that will be ignored because their cost of access is greater than a full table scan.

For a system with no System Statistics gathered, which is actually the majority of cases, then the following calculations are used for the disk read times:
  • sreadtim = ioseektim + (db_block_size / iotfrspeed)
  • mreadtim = ioseektim + (db_file_multiblock_read_count * db_block_size / iotfrspeed)
By default ioseektim will be 10 milliseconds and iotfrspeed will be 4 KB / millisecond.

This means that the only non-table dependent values in the fully expanded formula are for db_block_size and db_file_multiblock_read_count. These can only be obtained directly from the Oracle database if the user has SELECT permission on the dynamic performance views (V$PARAMETER specifically). And generally this is not true for normal users. To work around this, the SQL script below simply prompts the user to enter these two values.

The SQL script then calculates the derived values, and then uses these on all indexes on all tables to list those that fail the test i.e. number of distinct values in the index is too low.

As mentioned earlier, we can only ignore the depth of the index when the table is large enough, so the SQL includes an additional constraint on the number of blocks in a table, which is hardcoded at 100 blocks. You could easily change this to another value if desired.

This is a SQL*Plus script and must be run via SQL*Plus, as it uses SQL*Plus features such as substitution variables. And remember that your statistics must be up to date on each table and index in the database.

--
-- Check which indexes on all tables are better or worse than a full table scan
-- When the number of distinct values in a column is low, a full table scan
-- is more efficient (less I/Os) than using an index.
--
set define on
set verify off
set heading off
--
prompt
prompt Report to show which indexes are selective enough and which are not.
prompt Non-selective indexes will be ignored and full table scans preferred.
prompt

define small_table_threshold = 100

accept block_size prompt 'Enter database block size in bytes (e.g. 8192) : '
accept mbrc prompt 'Enter db_file_multiblock_read_count value (e.g. 8): '

prompt Using following database wide configuration settings:
prompt : Database Block size is &&block_size (bytes)
prompt : db_file_multiblock_read_count is &&mbrc
prompt : Threshold for a small table is &&small_table_threshold (blocks)
prompt : (Smaller tables than this are ignored in this report)
prompt : [If these are incorrect, edit this script and re-run]

column sreadtim new_value sreadtim
column mreadtim new_value mreadtim
column effective_mbrc new_value effective_mbrc

set termout off
-- Hide from screen internal calculations of derived values
select 10 + (&&block_size / 4096) sreadtim from dual ;
select 10 + (&&mbrc * &&block_size / 4096) mreadtim from dual ;
select &&mbrc * &&sreadtim / &&mreadtim effective_mbrc from dual ;
set termout on

prompt
prompt Assuming that system wide statistics have these derived values:
prompt : Single Block Read Time used is &&sreadtim (milliseconds)
prompt : Multi Block Read Time used is &&mreadtim (milliseconds)

set heading on
column table_name heading 'Table' format a20
column index_name heading 'Index Name' format a20
column distinct_keys heading 'Number of|Distinct|Values' format 999,999
column min_ndv heading 'Min|NDV' format 999,999
column selectivity heading 'Selectivity'
column sel heading 'Sel?'
column blocks heading 'Blocks' format 999,999
column mb heading 'Table|MB' format 999,999

select table_name, index_name, distinct_keys, min_ndv,
case
when (distinct_keys < min_ndv)
then 'N'
else 'Y'
end sel,
(blocks * &&block_size / (1024 * 1024)) mb
from ( select t.table_name, t.blocks, t.num_rows num_trows,
i.index_name, i.num_rows num_irows, i.distinct_keys,
&&effective_mbrc *
((i.leaf_blocks + i.clustering_factor) / t.blocks) min_ndv
from user_ind_statistics i, user_tables t
where t.table_name = i.table_name
and i.num_rows != 0
)
where distinct_keys < min_ndv
and blocks >= &&small_table_threshold
order by table_name, index_name ;

prompt Selectivity (S) indicates whether index will be chosen or not in a query
prompt given the values of the database settings you have entered.
prompt

Running this should list indexes that will NOT generally be used by the Optimizer for any query you might run that references that table. There might be exceptional cases where the Optimizer might use such an index e.g. an Index Fast Full Scan, but generally such indexes would not be used as expected for direct access to the matching rows.

As ever, remember that higher values for db_file_multiblock_read_count lower the cost for a full table scan, and so lower the threshold at which a full table scan becomes cheaper than an index access.

2 comments:

Brian Tkatch said...

John,

Wow!

I've been switch to SQL Server, so there isn't really anything for me to test this on. But, this is something that looks very useful. I wish i was "into it" enough to understand everything you explained.

A suggestion, perhaps. Instead of asking for user input for multiread and block size, being you are in a script, why not host out and parse the config file yourself?

RCMorilla said...

Is this?


set serveroutput on
DECLARE
C_TABELA_PEQUENA CONSTANT INTEGER := 100;
V_BLOCK_SIZE INTEGER;
V_SREADTIM NUMBER;
V_MREADTIM NUMBER;
V_MBRC NUMBER;
V_MBRC2 NUMBER;
V_IOSEEKTIM NUMBER;
V_IOTFRSPEED NUMBER;
CURSOR PEGA_MBRC IS
SELECT TP.VALUE AS MBRC
FROM V$PARAMETER TP
WHERE TP.NAME = 'db_file_multiblock_read_count';
CURSOR PEGA_INDICES (P_MBRC NUMBER) IS
WITH
ANALISE AS (
SELECT T.OWNER AS TABLE_OWNER
, T.TABLE_NAME
, TBT.BLOCK_SIZE AS TABLE_BLOCK_SIZE
, T.BLOCKS AS BLK_UNDER_HWM
, S.OWNER AS INDEX_OWNER
, S.INDEX_NAME
, TBI.BLOCK_SIZE AS INDEX_BLOCK_SIZE
, (T.BLOCKS * NVL(V_MREADTIM,(V_IOSEEKTIM + (P_MBRC * TBT.BLOCK_SIZE / V_IOTFRSPEED))))/
(P_MBRC * NVL(V_SREADTIM,(V_IOSEEKTIM + (TBT.BLOCK_SIZE / V_IOTFRSPEED))))
AS FTS_COST
, I.BLEVEL + ((S.LEAF_BLOCKS + S.CLUSTERING_FACTOR) * (1 / S.DISTINCT_KEYS ))
AS INDEX_COST
from dba_IND_STATISTICS s
, DBA_TABLES T
, DBA_INDEXES I
, DBA_TABLESPACES TBi
, DBA_TABLESPACES TBt
where S.NUM_ROWS != 0
and S.OBJECT_TYPE = 'INDEX'
and S.TABLE_OWNER = T.OWNER
and S.TABLE_NAME = T.TABLE_NAME
and S.TABLE_OWNER = i.table_OWNER
and T.TABLE_NAME = I.TABLE_NAME
AND S.INDEX_NAME = I.INDEX_NAME
and I.TABLESPACE_NAME = TBi.TABLESPACE_NAME
and t.TABLESPACE_NAME = TBt.TABLESPACE_NAME
)
select a.TABLE_OWNER||'.'||a.TABLE_NAME as TABELA
, a.INDEX_OWNER||'.'||a.INDEX_NAME as indice
, a.FTS_COST
, a.INDEX_COST
from ANALISE a
WHERE A.INDEX_COST > FTS_COST
--and a.BLK_UNDER_HWM >= C_TABELA_PEQUENA
order by a.TABLE_NAME, a.INDEX_NAME;
function ESTATISTICA (P_NOME varchar2)
return number
is
cursor PEGA_ESTATISTICA
is
select PVAL1
from SYS.AUX_STATS$
where PNAME = P_NOME;
v_valor number;
begin
open PEGA_ESTATISTICA;
FETCH PEGA_ESTATISTICA into v_valor;
close PEGA_ESTATISTICA;
return v_valor;
end;
begin
open PEGA_MBRC;
FETCH PEGA_MBRC into V_MBRC2;
close PEGA_MBRC;
V_IOTFRSPEED := ESTATISTICA('IOTFRSPEED');
v_SREADTIM := ESTATISTICA('SREADTIM');
V_MREADTIM := ESTATISTICA('MREADTIM');
V_MBRC := ESTATISTICA('MBRC');
V_IOSEEKTIM := ESTATISTICA('IOSEEKTIM');
V_IOTFRSPEED := ESTATISTICA('IOTFRSPEED');
FOR I IN PEGA_INDICES (V_MBRC2)
LOOP
DBMS_OUTPUT.PUT('Tabela: '||I.TABELA||' Custo FTS: '||i.FTS_COST);
dbms_output.put_line(' - ├Źndice: '||i.indice||' Custo ├Źndice: '||i.INDEX_COST);
end LOOP;
end;
/