MySQL Handler in PostgresQL - mysql

Question

Is it possible to realize the "MySQL Handler" in PostgreSQL?
Using a cursor is nearly the tool that I search.
It permits to move fast forward and backward, row by row. Without fetching a big resultset.
DECLARE mycursor CURSOR FOR SELECT * FROM mytable ORDER BY "name";
But how to set the cursor at the beginning at a certain row?
For example to start the list at the first "M" name.
If I use this cursor:
DECLARE mycursor CURSOR FOR
SELECT *
FROM mytable
WHERE "name" LIKE 'M%' ORDER BY "name";
I can only move forward and backward trough the "M"-Records, but no more step backward to the "A" or forward to the "Z"-Records.
I only found a solution to get the "first M-Record" with thhe absolute row-number via ROW_NUMBER() and OVER() of the whole sorted resultset.
Then to create the cursor on the whole resultset (A to Z) and to move the cursor to the first M-occurence with
MOVE FORWARD nr_of_first_m FROM mycursor;
Is there a better solution? Because it takes over 1000ms to perform these queries.

Answer 1

Per your link, HANDLER seems to be a MySQL extension that exposes low level ISAM-like access to applications. I've worked with similar interfaces in old direct-access shared-file ISAM database products in the past, and I'm pleasantly surprised to see it in a client/server SQL database. (If I'd known about it four years ago it would've made writing a replacement intepreter for a 1983 4GL my previous job used for a business application a lot easier).
PostgreSQL does not have any equivalent feature exposed at the SQL level. The closest it comes is a scrollable cursor - but because of visibility rules and transaction isolation, this may require materializing a sorted copy of the data set (though not generally for a simple cursor over a SELECT from a single table with no aggregation, windows, etc, that is not with hold). As you have already noted, however, PostgreSQL's FETCH and MOVE do not support value-based scrolling, only row-count based scrolling, which appears to make them unsuitable for your requirements.
The usual solution in PostgreSQL for "get me the prior row" or "get me the next row" is to work in SNAPSHOT or SERIALIZABLE isolation and use queries like:
SELECT * FROM my_table WHERE the_key > 'last_seen_key_value' ORDER BY the_key ASC LIMIT 1;
e.g. if you last saw 'Matthew' and want the next name:
SELECT * FROM my_table WHERE "name" > 'Matthew' ORDER BY "name" ASC LIMIT 1;
or the previous name:
SELECT * FROM my_table WHERE "name" < 'Matthew' ORDER BY "name" DESC LIMIT 1;
This strategy works very well so long as you have a suitable index on the key - for a utf-8 db, you'll want a text_pattern_ops b-tree index on "name" in this case. It's still nowhere near as fast as raw access to an ISAM table (like MyISAM), but it's probably pretty similar to what MySQL's doing when you use a handle on an InnoDB table internally because it has to solve similar problems to PostgreSQL. There's some parsing and planning overhead, but you can get rid of some of that by keeping a pair of prepared statements and re-using them.
It's possible that you could implement something like HANDLE in PostgreSQL using low level C code to access the heap and indexes, but getting it right in the face of concurrent activity, vacuum, etc would be challenging. Considerable experience in PostgreSQL's innards would be required, especially with use of the index access methods. If you're prepared to put in the couple of months of work required to learn and implement it, you could study the sources and then post a preliminary proposal on pgsql-hackers. Or, if this is business critical functionality and you need PostgreSQL for other purposes, you could contact someone who does professional PostgreSQL development - but don't expect a low quote for something like this.
Otherwise, if you need such direct, low-level access it may be best to stick to a database product that directly supports what you need.