Under what conditions do these two SQL queries give different results? - sql

Question

Disclaimer: I'm helping a person learn SQL by using an online tutorial. So you can consider this as a homework question.
There are 3 SQL Server tables that we are dealing with here:
Ships (name, class)
Classes - different classes of the ship (class)
Outcomes - what has happened to that ship (ship, result)
Now there are several crazy things in the layout of the database, the biggest one being that the ships in the Outcomes table may not be present in the Ships table when they are named the same way as the class in Class.
The point is to get the number of sunk ships of each class. I have helped the student to get to the following SQL:
Select
dbo.Classes.[class], Count(dbo.Outcomes.ship) as [count]
from
dbo.Classes
left join
dbo.Ships on dbo.Ships.[class] = dbo.Classes.[class]
left join
dbo.Outcomes on (dbo.Outcomes.ship = dbo.Classes.[class] or
dbo.Outcomes.ship = dbo.Ships.name)
and dbo.Outcomes.result = 'sunk'
Group by
dbo.Classes.[class]
However, it, apparently, is the incorrect solution, as it can on some occasions return incorrect results. On the web i have managed to find the following solution to this tutorial:
select
classes.class, count(T.ship)
from
classes
left join
(select
ship, class
from
outcomes
left join
ships on ship = name
where
result = 'sunk'
union
select
ship, class
from
outcomes
left join
classes on ship = class
where
result = 'sunk') as T on classes.class = T.class
group by
classes.class
But I cannot understand under which conditions will the results be different. Doesn't the Union operation of using two different join paths serve the exactly same function as does OR in the condition of the join?
P.S. This particular question in the tutorial is actually marked as 2 on the scale from 1-5 for difficulty. So i feel myself quite stupid.

Answer 1

With this dataset:
with Ships as (
select * from (values
('HMS Prince of Wales','King George V')
,('King George V','King George V')
)Ships(name,class)
),
Classes as (
select * from (values
('King George V')
)Classes(class)
),
Outcomes as (
select * from (values
('HMS Prince of Wales','sunk')
,('King George V','sunk')
)Outcomes(ship,result)
)
the two queries you provide respectively yield:
class count
------------- -----------
King George V 3
class
------------- -----------
King George V 2
The reason for the difference is that UNION is a set operator that eliminates duplicates (unlike UNION ALL) while the OR operator doesn't. We can test this by replacing UNION in the second query with UNION ALL, which now yields:
class
------------- -----------
King George V 3
just as in your first proposed solution.

Answer 2

The queries might return different results in many cases. One obvious case is when a sunk ship matches both class and name in outcomes. The union in the second query will return one row in this case. The join in the first query will return two rows. Hence the counts will be different.
I think you could fix this particular issue by using count(distinct) in the first query.

Answer 3

Needed goal :
"The point is to get the number of sunk ships of each class. I have helped the student to get to the following SQL:"
Sudo code should be created in three steps. You would need to break them into working steps
select * from class
//create a list of all of the classes that exists in your db
select * from [working previous statement] where results = "sunk"
//create another select statement that uses the previous select statement to refine results
//then refine it to have ships that have been sunk
select count from [[previous statement with the two selects]]
//This create the count of all of the sunk ships.
select count from [[previous statement with the two selects]] group by [previous statement with one select]
//this one should create the individual count of all of the sunken ships based on it's class
select sum from [[your pick of which statement]]
//do a sum
naturally you will need to do the linking so the code should be implemented as
select ship from ships sh, classes cl, outcome oc where sh.class = cl.class and oc.ship = sh.ship and oc.result = sunk group by cl.classes
then add the count steps in the mix.