How to optimise change history data for MySQL

Question

The previous table this data was stored in approached 3-4gb, but the data wasn't compressed before/after storage. I'm not a DBA so I'm a little out of my depth with a good strategy.

The table is to log changes to a particular model in my application (user profiles), but with one tricky requirement: we should be able to fetch the state of a profile at any given date.

Data (single table):

id, username, email, first_name, last_name, website, avatar_url, address, city, zip, phone

The only two requirements:

1. be able to fetch a list of changes for a given model
2. be able to fetch state of model on a given date

Previously, all of the profile data was stored for a single change, even if only one column was changed. But to get a 'snapshot' for a particular date was easy enough.

My first couple of solutions in optimising the data structure:

(1) only store changed columns. This would drastically reduce data stored, but would make it quite complicated to get a snapshot of data. I'd have to merge all changes up to a given date (could be thousands), then apply that to a model. But that model couldn't be a fresh model (only changed data is stored). To do this, I'd have to first copy over all data from current profiles table, then to get snapshot apply changes to those base models.

(2) store whole of data, but convert to a compressed format like gzip or binary or whatnot. This would remove ability to query the data other than to obtain changes. I couldn't, for example, fetch all changes where email = ''. I would essentially have a single column with converted data, storing the whole of the profile.

Then, I would want to use relevant MySQL table options, like ARCHIVE to further reduce space.

So my question is, are there any other options which you feel are a better approach than 1/2 above, and, if not, which would be better?

Answer 1

First of all, I wouldn't worry at all about a 3GB table (unless it grew to this size in a very short period of time). MySQL can take it. Space shouldn't be a concern, keep in mind that a 500 GB hard disk costs about 4 man-hours (in my country).

That being said, in order to lower your storage requirements, create one table for each field of the table you want to monitor. Assuming a profile table like this:

CREATE TABLE profile (
    profile_id INT PRIMARY KEY,
    username VARCHAR(50),
    email VARCHAR(50) -- and so on
);

... create two history tables:

CREATE TABLE profile_history_username (
    profile_id INT NOT NULL,
    username VARCHAR(50) NOT NULL, -- same type as profile.username
    changedAt DATETIME NOT NULL,
    PRIMARY KEY (profile_id, changedAt),
    CONSTRAINT profile_id_username_fk
        FOREIGN KEY profile_id_fkx (profile_id)
        REFERENCES profile(profile_id)
);

CREATE TABLE profile_history_email (
    profile_id INT NOT NULL,
    email VARCHAR(50) NOT NULL, -- same type as profile.email
    changedAt DATETIME NOT NULL,
    PRIMARY KEY (profile_id, changedAt),
    CONSTRAINT profile_id_fk
        FOREIGN KEY profile_id_email_fkx (profile_id)
        REFERENCES profile(profile_id)
);

Everytime you change one or more fields in profile, log the change in each relevant history table:

START TRANSACTION;

-- lock all tables
SELECT @now := NOW()
FROM profile
JOIN profile_history_email USING (profile_id)
WHERE profile_id = [a profile_id]
FOR UPDATE;

-- update main table, log change
UPDATE profile SET email = [new email] WHERE profile_id = [a profile_id];
INSERT INTO profile_history_email VALUES ([a profile_id], [new email], @now);

COMMIT;

You may also want to set appropriate AFTER triggers on profile so as to populate the history tables automatically.

Retrieving history information should be straightforward. In order to get the state of a profile at a given point in time, use this query:

SELECT
    (
        SELECT username FROM profile_history_username
        WHERE profile_id = [a profile_id] AND changedAt = (
            SELECT MAX(changedAt) FROM profile_history_username
            WHERE profile_id = [a profile_id] AND changedAt <= [snapshot date]
        )
    ) AS username,

    (
        SELECT email FROM profile_history_email
        WHERE profile_id = [a profile_id] AND changedAt = (
            SELECT MAX(changedAt) FROM profile_history_email
            WHERE profile_id = [a profile_id] AND changedAt <= [snapshot date]
        )
    ) AS email;

Answer 2

You need a slow changing dimension:

i will do this only for e-mail and telephone so you understand (pay attention to the fact of i use two keys, 1 as unique in the table, and another that is unique to the user that it concerns. This is, the table key identifies the the record, and the user key identifies the user):

table_id, user_id, email, telephone, created_at,inactive_at,is_current

• 1, 1, mario@yahoo.it, 123456, 2012-01-02, , 2013-04-01, no
• 2, 2, erik@telecom.de, 123457, 2012-01-03, 2013-02-28, no
• 3, 3, vanessa@o2.de, 1234568, 2012-01-03, null, yes
• 4, 2, erik@telecom.de, 123459, 2012-02-28, null, yes
• 5, 1, super.mario@yahoo.it, 654321,2013-04-01, 2013-04-02, no
• 6, 1, super.mario@yahoo.it, 123456,2013-04-02, null, yes

---

most recent state of the database

select * from FooTable where inactive_at is null

or

select * from FooTable where is_current = 'yes'

---

All changes to mario (mario is user_id 1)

select * from FooTable where user_id = 1;

---

All changes between 1 jan 2013 and 1 of may 2013

select * from FooTable where created_at between '2013-01-01' and '2013-05-01';

and you need to compare with the old versions (with the help of a stored procedure, java or php code... you chose)

select * from FooTable where incative_at between '2013-01-01' and '2013-05-01';

if you want you can do a fancy sql statement

select f1.table_id, f1.user_id, 
  case when f1.email = f2.email then 'NO_CHANGE' else concat(f1.email , ' -> ',  f2.email) end,
  case when f1.phone = f2.phone then 'NO_CHANGE' else concat(f1.phone , ' -> ',  f2.phone) end
  from FooTable f1 inner join FooTable f2 
on(f1.user_id = f2.user_id)
where f2.created_at in 
   (select max(f3.created_at) from Footable f3 where f3.user_id = f1.user_id 
      and f3.created_at < f1.created_at and f1.user_id=f3.user_id) 
 and f1.created_at between '2013-01-01' and '2013-05-01' ;

As you can see a juicy query, to compare the user_with the previews user row...

---

the state of the database on 2013-03-01

select * from FooTable where table_id in
   (select max(table_id) from FooTable where inactive_at <= '2013-03-01'  group by user_id 
     union
    select id from FooTable where inactive_at is null group by user_id having count(table_id) =1 );

I think this is the easiest way of implement what you want... you could implement a multi-million tables relational model, but then it would be a pain in the arse to query it

---

Your database is not big enough, I work everyday with one even bigger. Now tell me is the money you save in a new server worthy the time you spend on a super-complex relational model?

BTW if the data changes too fast, this approach cannot be used...

---

BONUS: optimization:

• create indexes on created_at, inactive_at, user_id and the pair

• perform partition (both horizontal and vertical)

Answer 3

You can't compress the data without having to uncompress it in order to search it - which is going to severely damage the performance. If the data really is changing that often (i.e. more than an average of 20 times per record) then it would be more efficient to for storage and retrieval to structure it as a series of changes:

Consider:

 CREATE TABLE profile (
   id INT NOT NULL autoincrement,
   PRIMARY KEY (id);
 );
 CREATE TABLE profile_data (
   profile_id INT NOT NULL,
   attr ENUM('username', 'email', 'first_name'
        , 'last_name', 'website', 'avatar_url'
        , 'address', 'city', 'zip', 'phone') NOT NULL,
   value CARCHAR(255),
   starttime DATETIME DEFAULT CURRENT_TIME,
   endtime DATETIME,
   PRIMARY KEY (profile_id, attr, starttime)
   INDEX(profile_id),
   FOREIGN KEY (profile_id) REFERENCES profile(id)
 );

When you add a new value for an existing record, set an endtime in the masked record. Then to get the value at a date $T:

 SELECT p.id, attr, value
 FROM profile p
 INNER JOIN profile_date d
 ON p.id=d.profile_id
 WHERE $T>=starttime
 AND $T<=IF(endtime IS NULL,$T, endtime);

Alternately just have a start time, and:

SELECT p.id, attr, value
 FROM profile p
 INNER JOIN profile_date d
 ON p.id=d.profile_id
 WHERE $T>=starttime
 AND NOT EXISTS (SELECT 1
   FROM prodile_data d2
   WHERE d2.profile_id=d.profile_id
   AND d2.attr=d.attr
   AND d2.starttime>d.starttime
   AND d2.starttime>$T);

(which will be even faster with the MAX concat trick).

But if the data is not changing with that frequency then keep it in the current structure.

Answer 4

if you try and put all occurring changes in different tables and later if you require an instance on some date you join them along and display by comparing dates, for example if you want an instance at 1st of july you can run a query with condition where date is equal or less than 1st of july and order it in asc ordering limiting the count to 1. that way the joins will produce exactly the instance it was at 1st of july. in this manner you can even figure out the most frequently updated module. also if you want to keep all the data flat try range partitioning on the basis of month that way mysql will handle it pretty easily.

Note: by date i mean storing unix timestamp of the date its pretty easier to compare.

Answer 5

I'll offer one more solution just for variety.

Schema

PROFILE
    id INT PRIMARY KEY,
    username VARCHAR(50) NOT NULL UNIQUE

PROFILE_ATTRIBUTE
    id INT PRIMARY KEY,
    profile_id INT NOT NULL FOREIGN KEY REFERENCES PROFILE (id),
    attribute_name VARCHAR(50) NOT NULL,
    attribute_value VARCHAR(255) NULL,
    created_at DATETIME NOT NULL DEFAULT GETTIME(),
    replaced_at DATETIME NULL

For all attributes you are tracking, simply add PROFILE_ATTRIBUTE records when they are updated, and mark the previous attribute record with the DATETIME it was replaced at.

Select Current Profile

SELECT *
FROM PROFILE p
    LEFT JOIN PROFILE_ATTRIBUTE pa
    ON p.id = pa.profile_id
WHERE p.username = 'username'
    AND pa.replaced_at IS NULL

Select Profile At Date

SELECT *
FROM PROFILE p
    LEFT JOIN PROFIILE_ATTRIBUTE pa
    ON p.id = pa.profile_id
WHERE p.username = 'username'
    AND pa.created_at < '2013-07-01'
    AND '2013-07-01' <= IFNULL(pa.replaced_at, GETTIME())

When Updating Attributes

• Insert the new attribute
• Update the previous attribute's replaced_at value

It would probably be important that the created_at for a new attribute match the replaced_at for the corresponding old attribute. This would be so that there is an unbroken timeline of attribute values for a given attribute name.

Advantages

• Simple two-table architecture (I personally don't like a table-per-field approach)
• Can add additional attributes with no schema changes
• Easily mapped into ORM systems, assuming an application lives on top of this database
• Could easily see the history for a certain attribute_name over time.

Disadvantages

• Integrity is not enforced. For example, the schema doesn't restrict on multiple NULL replaced_at records with the same attribute_name... perhaps this could be enforced with a two-column UNIQUE constraint
• Let's say you add a new field in the future. Existing profiles would not select a value for the new field until they save a value to it. This is opposed to the value coming back as NULL if it were a column. This may or may not be an issue.

If you use this approach, be sure you have indexes on the created_at and replaced_at columns.

There may be other advantages or disadvantages. If commenters have input, I'll update this answer with more information.