Find differences in name-value pairs across version IDs - mysql

Question

Say I have a table with 3 columns:version_id, name, value.
Conceptually, this table has a bunch of name-value pairs for each version_id.
How can I write a query that will show only the name value pairs of the top two version_ids where the name value pair is not the same across version-ids?
Additionally, I am wondering if there is a way to put the differing name-value pairs from the different version_ids side by side, or have the rows be right next to each other in the results.
Basically, I want like a diff of the two versions.
Example:
version_id name value
23459 jsLibrary2 JQuery_1_4_3
23459 jsLibrary1 CrossDomainAjax_1_0
23456 jsLibrary2 JQuery_1_4_2
23456 jsLibrary1 CrossDomainAjax_1_0
23456 groovyInclude2 GroovyUtilities
23454 jsLibrary2 JQuery_1_4_2
23454 jsLibrary1 CrossDomainAjax_1_0
23454 groovyInclude2 GroovyUtilities
Ideal query result:
23456 jsLibrary2 JQuery_1_4_2
23459 jsLibrary2 JQuery_1_4_3
23456 groovyInclude2 GroovyUtilities
23459 NULL NULL
Note that ideally it would note new name-value pairs (where the name doesn't exist in the smaller version_id) and deleted name-value pairs (where the name doesn't exist in the larger version_id)

Answer 1

I'm sure this can be simplified — or at least, I really hope it can — but:
SELECT name,
version_id_before,
( SELECT value
FROM property_history
WHERE name = t.name
AND version_id = version_id_before
) AS value_before,
( SELECT MIN(version_id)
FROM property_history
WHERE version_id > version_id_before
) AS version_id_after,
( SELECT value
FROM property_history
WHERE name = t.name
AND version_id =
( SELECT MIN(version_id)
FROM property_history
WHERE version_id > version_id_before
)
) AS value_after
FROM ( SELECT name,
CASE WHEN EXISTS
( SELECT 1
FROM property_history
WHERE name = ph1.name
AND version_id =
( SELECT MAX(version_id)
FROM property_history
)
)
THEN ( SELECT MAX(version_id)
FROM property_history ph2
WHERE NOT EXISTS
( SELECT 1
FROM property_history
WHERE name = ph1.name
AND version_id = ph2.version_id
AND value =
( SELECT value
FROM property_history
WHERE name = ph1.name
AND version_id =
( SELECT MAX(version_id)
FROM property_history
)
)
)
)
ELSE ( SELECT MAX(version_id)
FROM property_history
WHERE name = ph1.name
)
END AS version_id_before
FROM property_history ph1
GROUP
BY name
) AS t
WHERE version_id_before IS NOT NULL
;
(Disclaimer: tested only using your example data-set, for which it gives the result:
+----------------+-------------------+-----------------+------------------+--------------+
| name | version_id_before | value_before | version_id_after | value_after |
+----------------+-------------------+-----------------+------------------+--------------+
| groovyInclude2 | 23456 | GroovyUtilities | 23459 | NULL |
| jsLibrary2 | 23456 | JQuery_1_4_2 | 23459 | JQuery_1_4_3 |
+----------------+-------------------+-----------------+------------------+--------------+
I haven't made any effort to construct other data-sets to test it on.)

Answer 2

I think you'll need to use a couple of subqueries to get the desired results since you are looking for the first and second values. I'm assuming that the name is the 'key' that you have to group on, in which case something along these lines should work:
Select
firstVersion.firstVersionId,
firstVersionDetails.name as firstVersionName,
firstVersionDetails.value as firstVersionValue,
--second version values will be null if there is no second value
secondVersion.secondVersionId,
secondVersionDetails.name as secondVersionName, --always the same as firstVersionName because name is a key field
secondVersionDetails.value as secondVersionValue
From
(
Select
name,
Max(version_id) as firstVersionId
From versions
Group by name
) as firstVersion
join versions as firstVersionDetails--inner join because every name has a first version
on firstVersions.version_id = firstVersion.firstVersionId
left outer Join --outer join so we always get the first version and get the second version whenever there is one (in other words, does *not* limit data to names with at least 2 versions)
(
select
name,
Max(version_id) as secondVersionId
from versions
Group by name
) as secondVersion
on firstVersion.name=secondVersion.name
and secondVersion.version_id < firstVersion.firstVersionId --exclude the first version when calculating the 'max'. This is the part of the join that allows us to identify the second version
left outer join versions as secondVersionDetails --using outer join again so we don't limit our data to names with 2 versions
on secondVersion.secondVersionId = secondVersionDetails.version_id
Happy querying! :-)

Answer 3

How about this approach -
SELECT MAX(version_id) INTO #cur FROM tbl;
SELECT MAX(version_id) INTO #prev FROM tbl WHERE version_id < #cur;
SELECT name, #prev, MAX(IF(version_id = #prev, value, '')) AS prev_val, #cur, MAX(IF(version_id = #cur, value, '')) AS cur_val
FROM tbl
WHERE version_id IN (#prev, #cur)
GROUP BY name
HAVING cur_val <> prev_val;