MySQL comparing rows and getting changes - mysql

Question

Kind of lost on anything more than selects and joins and need help with this. I have a table that maintains attributes of products that are created. There are currently 110k rows in that table. I'm looking for a way to query that data and return data related to changes in the attributes of each product.
+-----------+---------+--------+--------+--------+
| attrib_id | prod_id | height | weight | length |
+-----------+---------+--------+--------+--------+
| 1 | 120 | 20 | 3 | 5 |
| 2 | 101 | 5 | 10 | 20 |
| 3 | 101 | 5 | 10 | 20 |
| 4 | 101 | 5 | 10 | 20 |
| 5 | 120 | 20 | 3 | 5 |
| 6 | 101 | 8 | 10 | 20 |
| 7 | 120 | 20 | 3 | 5 |
| 8 | 101 | 8 | 15 | 30 |
| 9 | 101 | 16 | 15 | 20 |
| 10 | 120 | 20 | 10 | 3 |
+-----------+---------+--------+--------+--------+
I would like to see something like this as an output when ever a product attributes change:
+-----------+---------+-------------+------------+------------+-------------+------------+------------+-------------+------------+------------+
| attrib_id | prod_id | orig_height | new_height | chg_height | orig_weight | new_weight | chg_weight | orig_length | new_length | chg_length |
+-----------+---------+-------------+------------+------------+-------------+------------+------------+-------------+------------+------------+
| 6 | 101 | 5 | 8 | 3 | 10 | | | 20 | | |
| 10 | 120 | 20 | | | 3 | 10 | 7 | 5 | 3 | -2 |
+-----------+---------+-------------+------------+------------+-------------+------------+------------+-------------+------------+------------+

Answer 1

Your expected output is bit incorrect.
You want to find min and max attrib_id and then use aggregation to find the required values:
select attrib_id,
prod_id,
original_height,
case when original_height = new_height then null else new_height end new_height,
nullif(new_height - original_height, 0) chg_height,
original_weight,
case when original_weight = new_weight then null else new_weight end new_weight,
nullif(new_weight - original_weight, 0) chg_weight,
original_length,
case when original_length = new_length then null else new_length end new_length,
nullif(new_length - original_length, 0) chg_length
from (
select t2.max_id attrib_id,
t.prod_id,
max(case when t.attrib_id = t2.min_id then t.height end) original_height,
max(case when t.attrib_id = t2.max_id then t.height end) new_height,
max(case when t.attrib_id = t2.min_id then t.weight end) original_weight,
max(case when t.attrib_id = t2.max_id then t.weight end) new_weight,
max(case when t.attrib_id = t2.min_id then t.length end) original_length,
max(case when t.attrib_id = t2.max_id then t.length end) new_length
from t
join (
select prod_id,
min(attrib_id) min_id,
max(attrib_id) max_id
from t
group by prod_id
) t2 on t.prod_id = t2.prod_id
and t.attrib_id in (t2.min_id, t2.max_id)
group by t.prod_id
) t;
Demo

Answer 2

OK, I will suggest a completely different approach. I thought about it reading the words “when ever a product attributes change” in your question. Other answers recompute all joins and aggregates every time, while your table t is essentially a history log which is bound to grow and grow and your query will be slower and slower. My approach is to create a table report and keep it in sync by means of a trigger. You have to start with two empty tables
DROP TABLE IF EXISTS t;
CREATE TABLE t (attrib_id INT, prod_id INT, height INT, weight INT, length INT);
DROP TABLE IF EXISTS report;
CREATE TABLE report (
attrib_id INT, prod_id INT,
orig_height INT, new_height INT, chg_height INT,
orig_weight INT, new_weight INT, chg_weight INT,
orig_length INT, new_length INT, chg_length INT
);
and then, define the trigger:
DROP TRIGGER IF EXISTS trig;
DELIMITER $$
CREATE TRIGGER trig AFTER INSERT ON t FOR EACH ROW BEGIN
DECLARE old_prod_id, old_height, old_weight, old_length INT;
SELECT prod_id, new_height, new_weight, new_length
INTO old_prod_id, old_height, old_weight, old_length
FROM report
WHERE prod_id = NEW.prod_id;
IF ISNULL(old_prod_id) THEN
INSERT INTO report(attrib_id, prod_id, orig_height, orig_weight, orig_length)
VALUES (NEW.attrib_id, NEW.prod_id, NEW.height, NEW.weight, NEW.length);
ELSEIF old_height != NEW.height OR old_weight != NEW.weight OR old_length != NEW.length
OR ISNULL(old_height) -- First change: I suppose checking one field is enough
THEN
UPDATE report SET
attrib_id = NEW.attrib_id,
new_height = NEW.height, chg_height = NEW.height - orig_height,
new_weight = NEW.weight, chg_weight = NEW.weight - orig_weight,
new_length = NEW.length, chg_length = NEW.length - orig_length
WHERE prod_id = NEW.prod_id;
END IF;
END$$
DELIMITER ;
When you fill t with the values you’ve given us, you get:
> SELECT * FROM report;
+-----------+---------+-------------+------------+------------+-------------+------------+------------+-------------+------------+------------+
| attrib_id | prod_id | orig_height | new_height | chg_height | orig_weight | new_weight | chg_weight | orig_length | new_length | chg_length |
+-----------+---------+-------------+------------+------------+-------------+------------+------------+-------------+------------+------------+
| 10 | 120 | 20 | 20 | 0 | 3 | 10 | 7 | 5 | 3 | -2 |
| 9 | 101 | 5 | 16 | 11 | 10 | 15 | 5 | 20 | 20 | 0 |
+-----------+---------+-------------+------------+------------+-------------+------------+------------+-------------+------------+------------+
and you have a much more flexible situation, where you can easily fine-tune your SELECT ... FROM report query as you like it.

Answer 3

I'm not sure if this is what are you looking for but it tracks all changes:
select attrib_id, prod_id,
height as ori_height, nheight as new_height, (nheight - height) as chg_height,
weight as ori_weight, nweight as new_weight, (nweight - weight) as chg_weight,
length as ori_length, nlength as new_length, (nlength - length) as chg_length
from (
select attr1.attrib_id, attr1.prod_id, attr1.height, attr1.weight, attr1.length
,(select attr2.height from attr attr2
where attr2.prod_id = attr1.prod_id and attr2.attrib_id > attr1.attrib_id limit 1) nheight
,(select attr2.weight from attr attr2
where attr2.prod_id = attr1.prod_id and attr2.attrib_id > attr1.attrib_id limit 1) nweight
,(select attr2.length from attr attr2
where attr2.prod_id = attr1.prod_id and attr2.attrib_id > attr1.attrib_id limit 1) nlength
from attr attr1
order by attr1.prod_id, attr1.attrib_id
) calc
;
It returns all changes, row by row:
+-----------+---------+------------+------------+------------+------------+------------+------------+------------+------------+------------+
| attrib_id | prod_id | ori_height | new_height | chg_height | ori_weight | new_weight | chg_weight | ori_length | new_length | chg_length |
+-----------+---------+------------+------------+------------+------------+------------+------------+------------+------------+------------+
| 2 | 101 | 5 | 5 | 0 | 10 | 10 | 0 | 20 | 20 | 0 |
| 3 | 101 | 5 | 5 | 0 | 10 | 10 | 0 | 20 | 20 | 0 |
| 4 | 101 | 5 | 8 | 3 | 10 | 10 | 0 | 20 | 20 | 0 |
| 6 | 101 | 8 | 8 | 0 | 10 | 15 | 5 | 20 | 30 | 10 |
| 8 | 101 | 8 | 16 | 8 | 15 | 15 | 0 | 30 | 20 | -10 |
| 9 | 101 | 16 | NULL | NULL | 15 | NULL | NULL | 20 | NULL | NULL |
+-----------+---------+------------+------------+------------+------------+------------+------------+------------+------------+------------+
| 1 | 120 | 20 | 20 | 0 | 3 | 3 | 0 | 5 | 5 | 0 |
| 5 | 120 | 20 | 20 | 0 | 3 | 3 | 0 | 5 | 5 | 0 |
| 7 | 120 | 20 | 20 | 0 | 3 | 10 | 7 | 5 | 3 | -2 |
| 10 | 120 | 20 | NULL | NULL | 10 | NULL | NULL | 3 | NULL | NULL |
+-----------+---------+------------+------------+------------+------------+------------+------------+------------+------------+------------+