Comparing All Columns That Share A Common Identifier in MS Access - sql

Question

Good day all.
I'm working on doing a comparison of records query and am having trouble finding an easier way to do it. Here's the run down:
Essentially, two people I work with have been entering data so each participant in our study will have two records in our database. I have to do a comparison of these records and return all discrepancies so they can be examined and fixed upon further review. Cannot think of an easy way to do this - there are a hefty amount of fields and I'd rather avoid having to do a comparison of each column manually.
Is there a method to compare from the following:
I'd want to compare all columns where Participant ID is the same. End goal is to make one column of all discrepancies per Participant.
Any ideas? My first attempt involved pulling all records where Count(Participant ID)>1 and then joined this on all the tables we're examining. As such, each participant had 2 rows - one for each extraction that was entered into the database. I then made these records side by side into one row so there was aType_1, bType_1, aType_2, bType_2, etc. I then began writing comparisons for each individual column pair, eg. aType_1<>bType_1, and returning the ID. This would effectively require a lot of coding and a massive set of union queries if I want to condense into a list of discrepancies. I cannot think of a simple way to do this... Thank you in advance for any ideas! :)

Answer 1

Hope I understand what you want.
SELECT a.Type_1, b.Type_1, a.Type_2, b.Type_2 etc.
FROM table a
INNER JOIN table b ON b.ParticipantID = a.ParticipantID
WHERE a.Type_1<>b.Type_1 AND a.Type_2<>b.Type_2 etc.

Answer 2

This is how far I managed to get. Not very far from what you managed I guess. But here goes anything. (Oh and this is in MySql >_<)
Assuming your participant-data table has some kind of unique valued column (primary key?), you could do something like the following:
If this is your table structure:
mysql> describe foo;
+-------+---------+------+-----+---------+-------+
| Field | Type | Null | Key | Default | Extra |
+-------+---------+------+-----+---------+-------+
| pid | int(11) | YES | | NULL | |
| type1 | int(11) | YES | | NULL | |
| type2 | int(11) | YES | | NULL | |
| type3 | int(11) | YES | | NULL | |
| pk | int(11) | YES | UNI | NULL | |
+-------+---------+------+-----+---------+-------+
5 rows in set (0.00 sec)
And you have data as follows:
mysql> select * from foo;
+------+-------+-------+-------+------+
| pid | type1 | type2 | type3 | pk |
+------+-------+-------+-------+------+
| 1 | 14 | 24 | 34 | 1 |
| 1 | 15 | 24 | 34 | 2 |
| 2 | 15 | 24 | 34 | 3 |
| 2 | 15 | 25 | 34 | 4 |
| 3 | 15 | 25 | 34 | 5 |
+------+-------+-------+-------+------+
5 rows in set (0.00 sec)
The following query returns a comparison of rows with matching pids:
mysql> select a.pid, a.type1 <> b.type1 as t1, a.type2 <> b.type2 as t2, a.type3 <> b.type3 as t3 from foo a join foo b on a.pid = b.pid where a.pk != b.pk group by a.pid having count(a.pid) > 1;
+------+------+------+------+
| pid | t1 | t2 | t3 |
+------+------+------+------+
| 1 | 1 | 0 | 0 |
| 2 | 0 | 1 | 0 |
+------+------+------+------+
2 rows in set (0.00 sec)
Same query, including the original column values for reference:
mysql> select *, a.pid, a.type1 <> b.type1 as t1, a.type2 <> b.type2 as t2, a.type3 <> b.type3 as t3 from foo a join foo b on a.pid = b.pid where a.pk != b.pk group by a.pid having count(a.pid) > 1;
+------+-------+-------+-------+------+------+-------+-------+-------+------+------+------+------+------+
| pid | type1 | type2 | type3 | pk | pid | type1 | type2 | type3 | pk | pid | t1 | t2 | t3 |
+------+-------+-------+-------+------+------+-------+-------+-------+------+------+------+------+------+
| 1 | 15 | 24 | 34 | 2 | 1 | 14 | 24 | 34 | 1 | 1 | 1 | 0 | 0 |
| 2 | 15 | 25 | 34 | 4 | 2 | 15 | 24 | 34 | 3 | 2 | 0 | 1 | 0 |
+------+-------+-------+-------+------+------+-------+-------+-------+------+------+------+------+------+
2 rows in set (0.00 sec)
If you somehow want to avoid writing down the name of each column (because you have 100s) you would want to consider using the INFORMATION_SCHEMA table to get the column names via a stored procedure maybe. Again this is MySql, but I'm sure MS-Access has an equivalent table.
Hope this helps at least a bit. :P

Answer 3

are you familiar with VBA? When I had to implement a solution similar to yours, I iterated through the fields collection of one entry's recordset and compared it with the value in field in the same ordinal position of the 2nd entry's recordset.
dim db as database
dim rs1 as recordset
dim rs2 as recordset
dim i as integer
dim bSame as boolean
bsame = true ' init
set rs1 = db.openrecordset("qryEntry1")
set rs2 = db.openrecordset("qryEntry2")
for i = 0 to rs1.fields.count
bSame = bSame and ( rs1(i) = rs2(i) )
next
here's the actual code I used:
Public Function verify(sPatientID As String) As Boolean
' returns true if all fields for entries 1 and 2 match'
Dim db As Database
Dim qdef As QueryDef
Dim rsDemo1 As Recordset
Dim rsDemo2 As Recordset
Dim rsDemoDiffs As Recordset
Dim rs As Recordset
Dim iDifferCountTestValues As Integer
Dim iDifferCountDemo As Integer
Dim iField As Integer
Dim bDiffers As Boolean
Dim bDemoEntered As Boolean
Dim bValuesEntered As Boolean
Dim bActive As Boolean
Dim bWithdrawn As Boolean
Dim bGroupSet As Boolean
Set db = CurrentDb
Set rs = db.OpenRecordset("select * from tblPatient where patientID = '" & sPatientID & "'")
bActive = rs("isActive")
bWithdrawn = rs("isWithdrawn")
bGroupSet = (rs("groupID") > 0)
Set qdef = db.QueryDefs("qryClearEntriesDifferPerPatient")
qdef.Parameters("patientIDCrit") = sPatientID
qdef.Execute
Set qdef = db.QueryDefs("qrySetEntry1DiffersForPatient")
qdef.Parameters("patientIDCrit") = sPatientID
qdef.Execute
Set qdef = db.QueryDefs("qrySetEntry2DiffersForPatient")
qdef.Parameters("patientIDCrit") = sPatientID
qdef.Execute
Set qdef = db.QueryDefs("qryTestValueEntriesDifferForPatient")
qdef.Parameters("patientIDCrit") = sPatientID
Set rs = qdef.OpenRecordset
bValuesEntered = Not rs.EOF
If rs.EOF Then
iDifferCountTestValues = 0
Else
iDifferCountTestValues = Abs(rs(1)) ' sum of true values is negative'
End If
db.Execute "Delete from tblDemographicEntriesDiffer where patientID = '" & sPatientID & "'"
Set rsDemo1 = db.OpenRecordset("select * from tblPatientDemographics where patientID = '" & sPatientID & "' and entryID = 1")
Set rsDemo2 = db.OpenRecordset("select * from tblPatientDemographics where patientID = '" & sPatientID & "' and entryID = 2")
bDemoEntered = (Not rsDemo1.EOF) And (Not rsDemo2.EOF)
Set rsDemoDiffs = db.OpenRecordset("Select * from tblDemographicEntriesDiffer")
For iField = 2 To rsDemo1.Fields.Count - 1 ' skip comparison of entryID'
If rsDemo1.Fields(iField).Value <> rsDemo2.Fields(iField).Value Then
bDiffers = True
ElseIf IsNull(rsDemo1.Fields(iField)) And Not IsNull(rsDemo2.Fields(iField)) Then
bDiffers = True
ElseIf Not IsNull(rsDemo1.Fields(iField)) And IsNull(rsDemo2.Fields(iField)) Then
bDiffers = True
Else
bDiffers = False
End If
If bDiffers Then
rsDemoDiffs.AddNew
rsDemoDiffs("patientID") = sPatientID
rsDemoDiffs("fieldName") = rsDemo1.Fields(iField).Name
rsDemoDiffs("entry1") = rsDemo1.Fields(iField).Value
rsDemoDiffs("entry2") = rsDemo2.Fields(iField).Value
rsDemoDiffs.Update
End If
Next
Set qdef = db.QueryDefs("qryDemoDiffersCountForPatient")
qdef.Parameters("patientIDCrit") = sPatientID
Set rs = qdef.OpenRecordset
If rs.BOF And rs.EOF Then
iDifferCountDemo = 0
Else
iDifferCountDemo = rs(1)
End If
verify = (iDifferCountTestValues + iDifferCountDemo = 0) And bDemoEntered And bActive
If bWithdrawn Then
verify = verify And bGroupSet
Else
verify = verify And bValuesEntered
End If
db.Execute "Update tblPatient set isVerified = " & verify & " where patientID = '" & sPatientID & "'"
rsDemo1.Close
rsDemo2.Close
rsDemoDiffs.Close
db.Close
End Function