Q:

PHP PDO Search backwards in MySQL without ORDER

I have a big ass mysql table, and I need to get most recent  1000 rows that match a condition. The obvious way is doing
try {
    $stmt = $dbh->prepare("SELECT id, date, field1, field2 
    FROM big_ass_table
    WHERE field1 >= 1000 and field2 <=4550
    ORDER BY date DESC LIMIT 0,1000");
    $stmt->execute();
    while ($row = $stmt->fetch(PDO::FETCH_ASSOC)) {
        print_r($row);
    }
    $stmt = null;
} catch (PDOException $e) {
    print $e->getMessage();
}

but this table is already 15M rows and the temporary SORT by date is taking forever. Casting it as a unix timestamp integer doesn't help much either.
I've tried using MongoDB for this task and building an index with reverse order on DATE does the trick without any sorting:
$cursor=$mongodb->big_ass_table
->find(array('$and'=>array($conditions)))
->hint( "date_-1" )
->limit(1000);

There are a number of reasons to keep using mysql for this task (although I'm growing more and more fond of MongoDB) so I'm hoping there's a way for mysql, specially PDO Mysql, to search backwards. 
According to MySQL documentation:

An index_col_name specification can end with ASC or DESC. These keywords are permitted for future extensions for specifying ascending or descending index value storage. Currently, they are parsed but ignored; index values are always stored in ascending order.

So I'm at a deadend here. Then I resorted to PDO. Is it possible to make it work with something like
try {
    $stmt = $dbh->prepare("SELECT id, date, field1, field2 
    FROM big_ass_table
    WHERE field1 >= 1000 and field2 <=4550
    LIMIT 0,1000", array(PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL));
    $stmt->execute();
    $row = $stmt->fetch(PDO::FETCH_ASSOC, PDO::FETCH_ORI_LAST);
    do {
      print_r($row);
    } while ($row = $stmt->fetch(PDO::FETCH_ASSOC, PDO::FETCH_ORI_PRIOR));
    $stmt = null;
}   catch (PDOException $e) {
    print $e->getMessage();
}

note I've removed the ORDER clause from the last one. I believe this way I'll still be capturing the first 1000 rows and then just printing them backwards, with isn't what I need to do. ¿Perhaps if I remove the LIMIT clause and then manually close the cursor when I reach 1000 rows would work? ¿Or would I be overloading the DB engine?

A:

There are at least 2 tricks to speed up your query.

To add some condition that uses index yet reduces the number of rows to sort. Say, to limit by some certain date which guaranteed to be out the range.
To create a reverse index - the very unix timestamp, but a negated one, with - in front. This way you will have an index by data but in reverse order. Don't forget to make this field of signed int type.

