A question often comes when talking about indexing: should we use multiple column indexes or multiple indexes on single columns? Peter Zaitsev wrote about it back in 2008 and the conclusion then was that a multiple column index is most often the best solution. But with all the recent optimizer improvements, is there anything different with MySQL 5.6?

Setup

For this test, we will use these 2 tables (same structure as in Peter’s post):

CREATE TABLE t1000merge ( id int not null auto_increment primary key, i int(11) NOT NULL, j int(11) NOT NULL, val char(10) NOT NULL, KEY i (i), KEY j (j) ) ENGINE=InnoDB; CREATE TABLE t1000idx2 ( id int not null auto_increment primary key, i int(11) NOT NULL, j int(11) NOT NULL, val char(10) NOT NULL, KEY ij (i,j) ) ENGINE=InnoDB; 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 CREATE TABLE t1000merge ( id int not null auto_increment primary key , i int ( 11 ) NOT NULL , j int ( 11 ) NOT NULL , val char ( 10 ) NOT NULL , KEY i ( i ) , KEY j ( j ) ) ENGINE = InnoDB ; CREATE TABLE t1000idx2 ( id int not null auto_increment primary key , i int ( 11 ) NOT NULL , j int ( 11 ) NOT NULL , val char ( 10 ) NOT NULL , KEY ij ( i , j ) ) ENGINE = InnoDB ;

Tables were populated with 1M rows for this test, i and j have 1000 distinct values (independent of each other). The buffer pool is large enough to hold all data and indexes.

We will look at this query on MySQL 5.5.35 and MySQL 5.6.15:

SELECT sum(length(val)) FROM T WHERE j=2 AND i BETWEEN 100 and 200 1 SELECT sum ( length ( val ) ) FROM T WHERE j = 2 AND i BETWEEN 100 and 200

Why this specific query? With MySQL 5.5, for t1000idx2, the optimizer estimates that the index on (i,j) is not selective enough and it falls back to a full table scan. While for t1000merge, the index on (j) is an obvious good candidate to filter efficiently.

Consequently this query has a better response on t1000merge (0.01s) than on t1000idx2 (0.45s).

On MySQL 5.6, this query is a good candidate for index condition pushdown (ICP), so we can reasonably hope that response time for t1000idx2 will improve.

ICP: FORCE INDEX to the rescue

Unfortunately the optimizer still prefers the full table scan which gives us the same bad response time:

mysql5.6> EXPLAIN SELECT sum(length(val)) FROM t1000idx2 WHERE j=2 AND i BETWEEN 100 and 200; +----+-------------+-----------+------+---------------+------+---------+------+---------+-------------+ | id | select_type | table | type | possible_keys | key | key_len | ref | rows | Extra | +----+-------------+-----------+------+---------------+------+---------+------+---------+-------------+ | 1 | SIMPLE | t1000idx2 | ALL | ij | NULL | NULL | NULL | 1000545 | Using where | +----+-------------+-----------+------+---------------+------+---------+------+---------+-------------+ 1 2 3 4 5 6 mysql5 . 6 > EXPLAIN SELECT sum ( length ( val ) ) FROM t1000idx2 WHERE j = 2 AND i BETWEEN 100 and 200 ; + -- -- + -- -- -- -- -- -- - + -- -- -- -- -- - + -- -- -- + -- -- -- -- -- -- -- - + -- -- -- + -- -- -- -- - + -- -- -- + -- -- -- -- - + -- -- -- -- -- -- - + | id | select_type | table | type | possible_keys | key | key_len | ref | rows | Extra | + -- -- + -- -- -- -- -- -- - + -- -- -- -- -- - + -- -- -- + -- -- -- -- -- -- -- - + -- -- -- + -- -- -- -- - + -- -- -- + -- -- -- -- - + -- -- -- -- -- -- - + | 1 | SIMPLE | t1000idx2 | ALL | ij | NULL | NULL | NULL | 1000545 | Using where | + -- -- + -- -- -- -- -- -- - + -- -- -- -- -- - + -- -- -- + -- -- -- -- -- -- -- - + -- -- -- + -- -- -- -- - + -- -- -- + -- -- -- -- - + -- -- -- -- -- -- - +

And what if we use FORCE INDEX ?

mysql5.6 > EXPLAIN SELECT sum(length(val)) FROM t1000idx2 FORCE INDEX(ij) WHERE j=2 AND i BETWEEN 100 and 200; +----+-------------+-----------+-------+---------------+------+---------+------+--------+-----------------------+ | id | select_type | table | type | possible_keys | key | key_len | ref | rows | Extra | +----+-------------+-----------+-------+---------------+------+---------+------+--------+-----------------------+ | 1 | SIMPLE | t1000idx2 | range | ij | ij | 8 | NULL | 188460 | Using index condition | +----+-------------+-----------+-------+---------------+------+---------+------+--------+-----------------------+ 1 2 3 4 5 6 mysql5 . 6 > EXPLAIN SELECT sum ( length ( val ) ) FROM t1000idx2 FORCE INDEX ( ij ) WHERE j = 2 AND i BETWEEN 100 and 200 ; + -- -- + -- -- -- -- -- -- - + -- -- -- -- -- - + -- -- -- - + -- -- -- -- -- -- -- - + -- -- -- + -- -- -- -- - + -- -- -- + -- -- -- -- + -- -- -- -- -- -- -- -- -- -- -- - + | id | select_type | table | type | possible_keys | key | key_len | ref | rows | Extra | + -- -- + -- -- -- -- -- -- - + -- -- -- -- -- - + -- -- -- - + -- -- -- -- -- -- -- - + -- -- -- + -- -- -- -- - + -- -- -- + -- -- -- -- + -- -- -- -- -- -- -- -- -- -- -- - + | 1 | SIMPLE | t1000idx2 | range | ij | ij | 8 | NULL | 188460 | Using index condition | + -- -- + -- -- -- -- -- -- - + -- -- -- -- -- - + -- -- -- - + -- -- -- -- -- -- -- - + -- -- -- + -- -- -- -- - + -- -- -- + -- -- -- -- + -- -- -- -- -- -- -- -- -- -- -- - +

This time ICP is used (see “Using index condition” in the Extra field)!

And the difference in response time is impressive:

– Without FORCE INDEX (full table scan): 0.45s

– With FORCE INDEX (multiple column index + index condition pushdown): 0.04s, a 10x improvement!

Additional thoughts

It is interesting to see that the optimizer fails to find the best execution plan for this simple query. The optimizer trace sheds some light:

mysql> SET optimizer_trace="enabled=on"; mysql> SELECT sum(length(val)) FROM T WHERE j=2 AND i BETWEEN 100 and 200; mysql> SELECT * FROM INFORMATION_SCHEMA.OPTIMIZER_TRACE; [...] "range_analysis": { "table_scan": { "rows": 1000545, "cost": 202835 }, 1 2 3 4 5 6 7 8 9 mysql > SET optimizer_trace = "enabled=on" ; mysql > SELECT sum ( length ( val ) ) FROM T WHERE j = 2 AND i BETWEEN 100 and 200 ; mysql > SELECT * FROM INFORMATION_SCHEMA .OPTIMIZER_TRACE ; [ . . . ] "range_analysis" : { "table_scan" : { "rows" : 1000545 , "cost" : 202835 } ,

This is the estimated cost for a full table scan.

Now we will see how the optimizer estimates the cost of the range scan using the ij index:

[...] "range_scan_alternatives": [ { "index": "ij", "ranges": [ "100 <= i <= 200" ], "index_dives_for_eq_ranges": true, "rowid_ordered": false, "using_mrr": false, "index_only": false, "rows": 188460, "cost": 226153, "chosen": false, "cause": "cost" } ] [...] 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 [ . . . ] "range_scan_alternatives" : [ { "index" : "ij" , "ranges" : [ "100 <= i <= 200" ] , "index_dives_for_eq_ranges" : true , "rowid_ordered" : false , "using_mrr" : false , "index_only" : false , "rows" : 188460 , "cost" : 226153 , "chosen" : false , "cause" : "cost" } ] [ . . . ]

At this stage the optimizer does not know if ICP can be used. This probably explains why the cost of the range scan is overestimated.

If we look at the optimizer trace for the query with the FORCE INDEX hint, ICP is only detected after the range scan is chosen:

[...] "refine_plan": [ { "table": "`t1000idx2` FORCE INDEX (`ij`)", "pushed_index_condition": "((`t1000idx2`.`j` = 2) and (`t1000idx2`.`i` between 100 and 200))", "table_condition_attached": null, "access_type": "range" } [...] 1 2 3 4 5 6 7 8 9 [ . . . ] "refine_plan" : [ { "table" : "`t1000idx2` FORCE INDEX (`ij`)" , "pushed_index_condition" : "((`t1000idx2`.`j` = 2) and (`t1000idx2`.`i` between 100 and 200))" , "table_condition_attached" : null , "access_type" : "range" } [ . . . ]

Conclusion

Multiple column index vs multiple indexes? Having indexes on single columns often lead to the optimizer using the index_merge access type, which is typically not as good as accessing a single index on multiple columns. MySQL 5.6 makes multiple column indexes more efficient than before with index condition pushdown.

But don’t forget that the optimizer is not perfect: you may have to use index hints to benefit from this feature.