如果ASC和DESC混合使用，为什么MySQL不能使用ORDER BY的索引？

Question

Let's say I have a very simple table like this:

CREATE TABLE `t1` (
  `key_part1` INT UNSIGNED NOT NULL,
  `key_part2` INT UNSIGNED NOT NULL,
  `value` TEXT NOT NULL,
  PRIMARY KEY (`key_part1`, `key_part2`)
) ENGINE=InnoDB

Using this table, I want to issue a query like this:

SELECT *
FROM `t1`
ORDER BY `key_part1` ASC, `key_part2` DESC
LIMIT 1

I had hoped that the ORDER BY in this query would get satisfied by the index. However, according to the MySQL documentation :

In some cases, MySQL cannot use indexes to resolve the ORDER BY , although it still uses indexes to find the rows that match the WHERE clause. These cases include the following:

• You mix ASC and DESC :

SELECT * FROM t1 ORDER BY key_part1 DESC, key_part2 ASC;

I tried a query similar to the above query and as expected, the EXPLAIN output says that such a query does a filesort. This doesn't totally make sense to me because I can do the following:

SELECT *
FROM `t1`
WHERE `key_part1` = (
    SELECT `key_part1`
    FROM `t1`
    ORDER BY `key_part1` ASC
    LIMIT 1
)
ORDER BY `key_part2` DESC
LIMIT 1

When I EXPLAIN this, it says both the subquery and the outer query do not use a filesort. Furthermore, I tried this kind of trick big table I have with a similar structure and found that it speeds up my query by 3 orders of magnitude.

My questions are

1. Are the two queries I show here equivalent? They seem like they are, but I may be missing something. If they are not, what kind of data would I need to have in my table to cause them to give different results?
2. Is there a reason that MySQL can't do this optimization trick on it's own, or is this just a case of an optimization that is possible, but just hasn't been written into MySQL?

If it matters, I am using MySQL 5.6.22.

Further clarification:

By "equivalent" I mean "produce the same result". Additionally, I am very aware that if I were to change LIMIT 1 to LIMIT 2 or something, the queries would no longer produce the same results. I am not interested in those cases, only in the case with LIMIT 1 .

Answer 1

It's not that MySQL is missing an optimization "trick", it's a property of how compound indexes work. MySQL can only do an index scan in one direction at a time, and has to go with how the index is ordered (so it can do computer-sciency things like binary search, etc).

Let's look at your sample query:

SELECT * FROM t1 WHERE key_part1 = ( SELECT key_part1 FROM t1 ORDER BY key_part1 ASC LIMIT 1 ) ORDER BY key_part2 DESC LIMIT 1

This can order on key_part2 because all returned rows will have an identical key_part1. So basically mysql can ignore that part of the index; it is functionally identical to ORDER BY key_part1 DESC, key_part2 DESC . The direction of the ORDER BY in your subquery is irrelevant because it was in a subquery.

Edit

To be clear, your example query really looks like this:

SELECT * FROM t1 WHERE key_part1 = #{some value} ORDER BY key_part2 DESC LIMIT 1

Where #{some value} is the result of a subselect. It should be clear now why this sort doesn't need a filesort, because you are not sorting by key_part1 at all. In fact, there is no need to, because all returned rows will have identical key_part1 .