The MySQL database is used in thousands of third-party applications, but what can you do when you want to use MySQL with an application, but that application’s queries or data doesn’t match MySQL’s data type or SQL format?
This post will show you three ways to alter a query or mismatched data when you don’t have control of the application’s source code. Of course, there are hundreds of different ways to do what I am about to show you. In this example, I will show you how to use the MySQL Query Rewrite Plugin along with a trigger to alter the non-conforming data. I will also show you an example of manipulating data with a stored procedure.
A customer emailed me with a problem. They wanted to use MySQL for a third-party application, but they didn’t have access to the source code. Their main problem was the application’s TIMESTAMP format didn’t conform to MySQL’s TIMESTAMP format. To be specific, this application produced a TIMESTAMP value that included a trailing time zone, such as “2018-09-05 17:00:00 EDT”. MySQL has two column data types where you can store both the date and time in one column: TIMESTAMP and DATETIME – but MySQL cannot handle TIMESTAMP or DATETIME data with a trailing time zone.
When a TIMESTAMP value is being inserted into a row, MySQL converts the TIMESTAMP value from the current time zone set by the MySQL server (see Time Zone Support) to UTC (Coordinated Universal Time) for storage, and converts the data back from UTC to the current time zone (of the server) when retrieved. (This conversion does not occur for other types such as DATETIME.) By default, the current time zone for each connection is the server’s local time. The time zone can be set on a per-connection basis, and as long as the time zone setting remains constant, you will get back the same value you stored. If you store a TIMESTAMP value, and then change the time zone and retrieve the value, the retrieved value is different from the value you stored. This occurs because the same time zone was not used for conversion in both directions. The current time zone is available as the value of the time_zone system variable. For more information, see Section 5.1.12, “MySQL Server Time Zone Support”.
(From: https://dev.mysql.com/doc/refman/8.0/en/datetime.html)
The customer told me that this application would only be sending data with two different trailing time zones – Central and Eastern. With daylight-savings in use in both of these time zones, this would give us four possible trailing time zone values – CDT, CST, EDT and EST. What we want to do is to intercept the query, and write this TIMESTAMP data to a different column, and then convert the value to UTC time to be stored in the correct column in the database. Because we don’t have access to the source code, I am assuming we have full access to the MySQL database.
The MySQL Rewrite Plugin
In MySQL version 5.7, a plugin named the “Query Rewrite Plugin” was introduced. This plugin can examine SQL statements received by the server and modify those statements before the server executes them. In other words, this gives you the ability to intercept “bad” queries and re-format them to be “good” queries for use with MySQL – or to rewrite the queries to do whatever you need. Think of it as a way to change the source code without actually having the source code.
Installing the plugin is fairly easy. In MySQL version 8.0, you install (or uninstall) the plugin via an SQL script provided with your MySQL installation. The script is named install_rewriter.sql and is located in the “share” directory under your MySQL home directory.
# cd /usr/local/mysql/share (your directory may be different)
# mysql -u root -p < install_rewriter.sql
Enter password: (enter root password here)
The script only takes a few seconds to load (The uninstall script is named uninstall_rewriter.sql). To check and make sure the plugin was installed, run this command from within MySQL:
mysql> SHOW GLOBAL VARIABLES LIKE 'rewriter_enabled';
+------------------+-------+
| Variable_name | Value |
+------------------+-------+
| rewriter_enabled | ON |
+------------------+-------+
1 row in set (0.00 sec)
The plugin was installed correctly if the column named “Value” is set to “ON“.
For this example, I am going to create a small table with three columns, and assume that this is an table from a third-party application. The date_time_value column is where the application would normally store the timestamp information.
mysql> create database test;
Query OK, 1 row affected (0.01 sec)
mysql> use test;
Database changed
mysql> CREATE TABLE `time_example` (
`idtime` int(11) NOT NULL AUTO_INCREMENT,
`action_record` varchar(30) NOT NULL,
`date_time_value` timestamp NULL DEFAULT NULL,
PRIMARY KEY (`idtime`)
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=UTF8MB4;
Query OK, 0 rows affected (0.03 sec)
The date_time_value column will obviously not be able to store timestamp data with a trailing time zone, but let’s see what happens when we try and insert a row of data – and let’s pretend that this is the query the application uses.
mysql> insert into test.time_example (action_record, date_time_value)
values ('Arrived at work', '2018-09-05 17:00:00 EDT');
Error Code: 1292. Incorrect datetime value: '2018-09-05 17:00:00 EDT'
for column 'date_time_value' at row 1
Of course, we get an error because the format for the timestamp is incorrect.
What we want to do is to alter the table and add a column to store this improperly-formatted timestamp data.
mysql> ALTER TABLE `test`.`time_example`
-> ADD COLUMN `date_time_storage` VARCHAR(23) NULL AFTER `date_time_value`;
Query OK, 0 rows affected (0.05 sec)
Records: 0 Duplicates: 0 Warnings: 0
Now that we have a column (date_time_storage) to store the “bad” timestamp data, we need to modify the incoming query so that it writes the timestamp data into the new column.
|
Note: In MySQL 8.0+, with the Query Rewrite Plugin, you can modify SELECT, INSERT, REPLACE, UPDATE, and DELETE statements. (Prior to MySQL 8.0.12 you could only modify SELECT statements)
|
This is the query the application is sending to the database:
insert into test.time_example (action_record, date_time_value) values (?, ?);
We want to modify the query to use the new date_time_storage column, instead of the date_time_value column. The new query would look like this:
insert into test.time_example (action_record, date_time_storage) values (?, ?);
Now that we have our old (bad) and new (good) queries, we can insert this into the rewrite_rules table of the query_rewrite database.
INSERT INTO query_rewrite.rewrite_rules
(pattern, replacement, pattern_database) VALUES(
'insert into test.time_example (action_record, date_time_value) values (?, ?)',
'insert into test.time_example (action_record, date_time_storage) values (?, ?)',
'time_example'
);
1 row(s) affected, 1 warning(s): 1105 Query 'insert into test.time_example
(action_record, date_time_value) values ('Left building', '2018-09-05 17:00:00 EDT')'
rewritten to 'insert into test.time_example (action_record, date_time_storage)
values ('Left building', '2018-09-05 17:00:00 EDT')' by a query rewrite plugin
(More examples may be found on this page: Query Rewrite Plugin Usage)
We need to execute a stored procedure named flush_rewrite_rules to make this query-rewrite change permanent: (See: https://dev.mysql.com/doc/refman/8.0/en/rewriter-query-rewrite-plugin-usage.html)
mysql> CALL query_rewrite.flush_rewrite_rules();
Query OK, 1 row affected (0.00 sec)
We can confirm the INSERT INTO query_rewrite.rewrite_rules by looking at the rewrite_rules table:
mysql> SELECT * FROM query_rewrite.rewrite_rules\G
*************************** 1. row ***************************
id: 1
pattern: insert into test.time_example (action_record, date_time_value) values (?, ?)
pattern_database: time_example
replacement: insert into test.time_example (action_record, date_time_storage) values (?, ?)
enabled: YES
message: NULL
pattern_digest: e823e987338aeae6d47f7a729e78f532d3ff3721237c15981bcd11fc2607efda
normalized_pattern: insert into `test`.`time_example` (`action_record`,`date_time_value`) values (?,?)
1 row in set (0.00 sec)
Next, let’s run the same query as before, and see if it puts the timestamp data that is supposed to go into the date_time_value column into the new date_time_storage column:
mysql> insert into test.time_example (action_record, date_time_value)
values ('Arrived at work', '2018-09-05 17:00:00 EDT');
Query OK, 1 row affected, 1 warning (0.01 sec)
And now the table contains this data:
mysql> select * from time_example;
+--------+-----------------+-----------------+-------------------------+
| idtime | action_record | date_time_value | date_time_storage |
+--------+-----------------+-----------------+-------------------------+
| 1 | Arrived at work | NULL | 2018-09-05 17:00:00 EDT |
+--------+-----------------+-----------------+-------------------------+
1 rows in set (0.00 sec)
We now have the timestamp with the time zone data stored in the MySQL database, but we need to convert this to a proper format, and put the result into the date_time_value column.
To do this, we can use a trigger.
Normally, you would want your application to produce data in the correct format, but in this example, we don’t have access to the source code. So, we can create a trigger to convert the “incorrectly-formatted” data in date_time_storage to the correct data and store it in date_time_value.
|
NOTE: These examples won’t work if your TIMESTAMP uses microseconds (6-digits) precision (example: ‘1970-01-01 00:00:01.000000’) – but you can modify the code to accommodate microseconds.
|
Here is the SQL to create the trigger:
DELIMITER $$
CREATE TRIGGER _time_zone_convert_insert2
AFTER INSERT ON time_example
FOR EACH ROW
BEGIN
DECLARE _date_time_no_tz varchar(20);
SET _date_time_no_tz = SUBSTRING(NEW.date_time_storage, 1, 20);
IF NEW.date_time_storage like '%EDT' THEN
SET NEW.date_time_value = CONVERT_TZ(_date_time_no_tz,'EST5EDT','GMT');
END IF;
IF NEW.date_time_storage like '%EST' THEN
SET NEW.date_time_value = CONVERT_TZ(_date_time_no_tz,'EST5EDT','GMT');
END IF;
IF NEW.date_time_storage like '%CDT' THEN
SET NEW.date_time_value = CONVERT_TZ(_date_time_no_tz,'EST5EDT','GMT');
END IF;
IF NEW.date_time_storage like '%CST' THEN
SET NEW.date_time_value = CONVERT_TZ(_date_time_no_tz,'EST5EDT','GMT');
END IF;
END$$
DELIMITER ;
Now that we have a trigger in place, let’s insert another line into the database – BUT, we still want to use the SQL from the application. The query will try and write to the date_time_value column, but the Query Rewrite Plugin will intercept the original query and substitute our new query instead – which will insert the timestamp data into the date_time_storage column, and then the trigger will convert the timestamp and place the correct value into the date_time_value column.
mysql> INSERT INTO time_example (action_record, date_time_value)
VALUES ('Lunch Break', '2018-09-05 18:00:00 EDT');
Query OK, 1 row affected (0.00 sec)
The table now contains a true timestamp column with the correct timestamp value in UTC. (The old row didn’t change)
mysql> SELECT * FROM test.time_example;
+--------+------------+---------------------+-------------------------+
| idtime | product_id | date_time_value | date_time_storage |
+--------+------------+---------------------+-------------------------+
| 1 | time now1 | NULL | 2018-09-05 18:00:00 EDT |
| 2 | time now2 | 2018-09-05 22:00:00 | 2018-09-05 18:00:00 EDT |
+--------+------------+---------------------+-------------------------+
2 rows in set (0.00 sec)
But what about stored procedures?
The easiest way to handle the time zone conversion is with a trigger. But, to show you how stored procedures can do the same thing, I have an example of a stored procedure. In this example, I will be passing the values of the idtime and date_time_storage columns.
This example will be similar to the one above – I created a table named time_example, but this time, I am including the extra column:
'CREATE TABLE `time_example` (
`idtime` int(11) NOT NULL AUTO_INCREMENT,
`action_record` varchar(30) NOT NULL,
`date_time_value` timestamp NULL DEFAULT NULL,
`date_time_storage` varchar(23) DEFAULT NULL,
PRIMARY KEY (`idtime`)
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8'
I then inserted a row, where I am storing the time stamp with the time zone information:
mysql> insert into test.time_example (action_record, date_time_storage)
values ('Left work', '2018-09-05 17:00:00 EDT’);
Query OK, 1 row affected (0.00 sec)
Here is what the row looks like:
mysql> SELECT * FROM test.time_example;
+--------+------------+-----------------+-------------------------+
| idtime | product_id | date_time_value | date_time_storage |
+--------+------------+-----------------+-------------------------+
| 1 | Left work | NULL | 2018-09-05 17:00:00 EDT |
+--------+------------+-----------------+-------------------------+
1 row in set (0.00 sec)
Again, the date_time_storage column is a temporary storage column. I will call the stored procedure, and provide the idtime and date_time_storage values. The stored procedure which will look at the last three characters in the date_time_storage column, and then convert the time to UTC, which is then stored in the date_time_value column.
call _check_time_zone('1','2018-09-05 17:00:00 EDT');
Now the row looks like this, where the date_time_value column is now stored as UTC:
mysql> SELECT * FROM test.time_example;
+--------+------------+---------------------+-------------------------+
| idtime | product_id | date_time_value | date_time_storage |
+--------+------------+---------------------+-------------------------+
| 1 | Left work | 2018-09-05 21:00:00 | 2018-09-05 17:00:00 EDT |
+--------+------------+---------------------+-------------------------+
1 row in set (0.00 sec)
And here is the code to create the stored procedure:
DELIMITER $$
CREATE DEFINER=`root`@`localhost`
PROCEDURE `_check_time_zone`(IN _id_time INT, IN _date_time_storage VARCHAR(23))
BEGIN
DECLARE _date_time_no_tz varchar(20);
SET _date_time_no_tz = SUBSTRING(_date_time_storage, 1, 20);
IF _date_time_storage like '%EDT' THEN
UPDATE time_example SET date_time_value = CONVERT_TZ(_date_time_no_tz,'EST5EDT','GMT')
WHERE idtime = _id_time;
END IF;
IF _date_time_storage like '%EST' THEN
UPDATE time_example SET date_time_value = CONVERT_TZ(_date_time_no_tz,'EST5EDT','GMT')
WHERE idtime = _id_time;
END IF;
IF _date_time_storage like '%CDT' THEN
UPDATE time_example SET date_time_value = CONVERT_TZ(_date_time_no_tz,'CST5CDT','GMT')
WHERE idtime = _id_time;
END IF;
IF _date_time_storage like '%CST' THEN
UPDATE time_example SET date_time_value = CONVERT_TZ(_date_time_no_tz,'CST5CDT','GMT')
WHERE idtime = _id_time;
END IF;
IF _date_time_storage like '%UTC' THEN
UPDATE time_example SET date_time_value = _date_time_no_tz
WHERE idtime = _id_time;
END IF;
END $$
DELIMITER ;
via Planet MySQL
Manipulating queries with non-conforming data via MySQL Query Rewrite Plugin, triggers and stored procedures
