Detect differences between two versions of the same table - sql

Question

I am looking for a method to detect differences between two versions of the same table.
Let's say I create copies of a live table at two different days:
Day 1:
CREATE TABLE table_1 AS SELECT * FROM table
Day 2:
CREATE TABLE table_2 AS SELECT * FROM table
The method should identify all rows added, deleted or updated between day 1 and day 2;
if possible the method should not use a RDBMS-specific feature;
Note: Exporting the content of the table to text files and comparing text files is fine, but I would like a SQL specific method.
Example:
create table table_1
(
col1 integer,
col2 char(10)
);
create table table_2
(
col1 integer,
col2 char(10)
);
insert into table_1 values ( 1, 'One' );
insert into table_1 values ( 2, 'Two' );
insert into table_1 values ( 3, 'Three' );
insert into table_2 values ( 1, 'One' );
insert into table_2 values ( 2, 'TWO' );
insert into table_2 values ( 4, 'Four' );
Differences between table_1 and table_2:
Added: Row ( 4, 'Four' )
Deleted: Row ( 3, 'Three' )
Updated: Row ( 2, 'Two' ) updated to ( 2, 'TWO' )

Answer 1

If you want differences in both directions. I am assuming you have an id, because you mention "updates" and you need a way to identify the same row. Here is a union all approach:
select t.id,
(case when sum(case when which = 't2' then 1 else 0 end) = 0
then 'InTable1-only'
when sum(case when which = 't1' then 1 else 0 end) = 0
then 'InTable2-only'
when max(col1) <> min(col1) or max(col2) = min(col2) or . . .
then 'Different'
else 'Same'
end)
from ((select 'table1' as which, t1.*
from table_1 t1
) union all
(select 'table2', t2.*
from table_2 t2
)
) t;
This is standard SQL. You can filter out the "same" records if you want to.
This assumes that all the columns have non-NULL values and that rows with a given id appear at most once in each table.

Answer 2

I think I found the answer - one can use this SQL statement to build a list of differences:
Note: "col1, col2" list must include all columns in the table
SELECT
MIN(table_name) as table_name, col1, col2
FROM
(
SELECT
'Table_1' as table_name, col1, col2
FROM Table_1 A
UNION ALL
SELECT
'Table_2' as table_name, col1, col2
FROM Table_2 B
)
tmp
GROUP BY col1, col2
HAVING COUNT(*) = 1
+------------+------+------------+
| table_name | col1 | col2 |
+------------+------+------------+
| Table_2 | 2 | TWO |
| Table_1 | 2 | Two |
| Table_1 | 3 | Three |
| Table_2 | 4 | Four |
+------------+------+------------+
In the example quoted in the question,
Row ( 4, 'Four' ) present in table_2 ; verdict row "Added"
Row ( 3, 'Three' ) present in table_1; verdict row "Deleted"
Row ( 2, 'Two' ) present in table_1 only; Row ( 2, 'TWO' ) present in table_2 only; if col1 is primary key then verdict "Updated"

Answer 3

If you can asasume that the table has a unique primary key then the following SQL statements will at the end have created three views which contain the changed, new and deleted IDs.
In the following "tbl1" is the old version and "tbl2" is the new version (same schema). The primary key in the table is assumed to be named "_id".
The intermediate view "_NewChanged" will contain both the new and changed IDs in the new version of the table and the view "_RemovedChanged" will contain both the removed and changed IDs in the new version.
To generate delta SQL statements is just a matter of programatically looping the respective views to create a delta set and do the delete, update, insert statemens that transforms the old version to the new version.
The solution have three caveats:
It will not pin-point exactly what columns have changed
The schema is assumed to be the same in the old and new version of the table
It assumes that the SQL statments INTERSECT and EXCEPT are available
To keep the code brief no comments have been inserted.
drop view if exists _NewChanged;
drop view if exists _RemovedChanged;
create view _NewChanged as
select * from tbl2
except
select * from tbl1;
create view _RemovedChanged as
select * from tbl1
except
select * from tbl2;
drop view if exists changed;
drop view if exists new;
drop view if exists deleted;
create view changed as
select _id from _NewChanged
intersect
select _id from _RemovedChanged;
create view new as
select _id from _NewChanged
except
select _id from _RemovedChanged;
create view deleted as
select _id from _RemovedChanged
except
select _id from _NewChanged;