MySql/MariaDB: Using Indexes in queries "directly"? - mysql

Question

I wonder if there is a possibility in MySql/MariaDB to make use of an index in a query directly. Suppose we have a simple unsorted table with timestamp/value-pairs:
CREATE TABLE simple (timestamp DATETIME, val INT);
By adding an index for the timestamp:
ALTER TABLE simple ADD INDEX ind_ts (timestamp);
we have a "fast access" to a kind of sort order of the timestamps.
Let's define a query that delivers the difference of values of consecutive values:
SELECT
c.timestamp AS currenttimestamp,
COALESCE(b.timestamp,'0000-00-00 00:00:00') AS timestampbefore,
c.val - COALESCE(b.val,0) AS difference
FROM simple c,
simple b
WHERE b.timestamp = (SELECT MAX(timestamp) FROM simple h WHERE h.timestamp < c.timestamp)
It is obvious that this query is circumstantial and expensive. A more convient way would be adding a column myindex to the table:
ALTER TABLE simple ADD COLUMN (myindex INT) AFTER timestamp;
and fill the new column with the chronical order of timestamp (e.g. by some php-code)
The new query would be simpler and less expensive:
SELECT
c.timestamp AS currenttimestamp,
COALESCE(b.timestamp,'0000-00-00 00:00:00') AS timestampbefore,
c.val - COALESCE(b.val,0) AS difference
FROM simple c
LEFT JOIN simple b ON c.myindex = b.myindex+1
The new column myindex is somehow similar to the database's table index ind_ts. (Why) is there no MySql construct to use ind_ts instead of myindex?

Answer 1

If you are using MySQL 8.0 or MariaDB 10.2 (or later), LEAD() and LAG() provide a simple way to see the row before or after.
If you are using an older version, then do a "self join". That is, JOIN the table to itself. Then line up the two "tables" offset by one. This may require generating a temp table with a fresh AUTO_INCREMENT to provide an easy way to do the offset. This may be slightly better than your idea about "myindex".
CREATE TABLE new_table (
myindex INT UNSIGNED AUTO_INCREMENT,
PRIMARY KEY(myindex))
SELECT * FROM simple;
Then
SELECT a.ts - b.ts AS diff -- (or whatever the math is)
FROM new_table AS a
JOIN new_table AS b ON a.myindex = b.myindex - 1
(This does not take care of the first and last rows of the table.)
Note: You cannot use a TEMPORARY TABLE since such cannot be JOINed to itself.