Question

Suppose I have a database table with two fields, ‘foo’ and ‘bar’. Neither of them are unique, but each of them are indexed. However, rather than being indexed together, they each have a separate index.

Now suppose I perform a query such as SELECT * FROM sometable WHERE foo='hello' AND bar='world'; My table a huge number of rows for which foo is ‘hello’ and a small number of rows for which bar is ‘world’.

So the most efficient thing for the database server to do under the hood is use the bar index to find all fields where bar is ‘world’, then return only those rows for which foo is ‘hello’. This is O(n) where n is the number of rows where bar is ‘world’.

However, I imagine it’s possible that the process would happen in reverse, where the fo index was used and the results searched. This would be O(m) where m is the number of rows where foo is ‘hello’.

So is Oracle smart enough to search efficiently here? What about other databases? Or is there some way I can tell it in my query to search in the proper order? Perhaps by putting bar='world' first in the WHERE clause?

Answer 1

Oracle will almost certainly use the most selective index to drive the query, and you can check that with the explain plan.

Furthermore, Oracle can combine the use of both indexes in a couple of ways — it can convert btree indexes to bitmaps and perform a bitmap ANd operation on them, or it can perform a hash join on the rowid’s returned by the two indexes.

One important consideration here might be any correlation between the values being queried. If foo=’hello’ accounts for 80% of values in the table and bar=’world’ accounts for 10%, then Oracle is going to estimate that the query will return 0.8*0.1= 8% of the table rows. However this may not be correct – the query may actually return 10% of the rwos or even 0% of the rows depending on how correlated the values are. Now, depending on the distribution of those rows throughout the table it may not be efficient to use an index to find them. You may still need to access (say) 70% or the table blocks to retrieve the required rows (google for ‘clustering factor’), in which case Oracle is going to perform a ful table scan if it gets the estimation correct.

In 11g you can collect multicolumn statistics to help with this situation I believe. In 9i and 10g you can use dynamic sampling to get a very good estimation of the number of rows to be retrieved.

To get the execution plan do this:

explain plan for SELECT * FROM   sometable WHERE  foo='hello' AND bar='world' / select * from table(dbms_xplan.display) / 

Contrast that with:

explain plan for SELECT /*+ dynamic_sampling(4) */        * FROM   sometable WHERE  foo='hello' AND bar='world' / select * from table(dbms_xplan.display) /