It's correct this Exercise Query SQL? - mysql

Question

I have this DB
aeroporto(1) <----> (n)volo(n) <----> (1)aereo
AEROPORTO: (pK)id_ap, città, naz, num_pist
VOLO: (pk)id_volo, data, (fk)id_part, oraPart, (fk)id_arr, oraArr, (fk)tipoAereo
AEREO: (pk)id_aereo, qta_merci, num_pass, cod_aereo
/ * French cities from which more than twenty direct flights to Italy leave * /
select a.citta
from volo as v, aereoporto as a, aereoporto as b
where a.id_ap = v.id_part and b.id_ap = v.id_arr and
a.nazione != b.nazione and a.nazione = 'francia' and count(b.citta = 'italia') > 20 ;
It's correct?
Sorry for my poor english.

Answer 1

Return the city name of all cities leaving 'francia' and arriving in 'italia' having a count of flights > 20.
SELECT a.citta
FROM volo as v
INNER JOIN aereoporto as a
on a.id_ap = v.id_part
INNER JOIN aereoporto as b
on b.id_ap = v.id_arr
WHERE a.nazione = 'francia'
and b.nazione = 'italia'
GROUP BY a.citta
HAVING count(v.id_volo) > 20 ;
GROUP BY allows us to group like cities together from 'francia' and the having clause lets us count the flights and ensure we only show cities having more than 20 flights.
However, this does assume that a citta is not duplicated per naz. For example: if the the same named city existed in different regions within francia; then we would have a problem. So if there were a Paris Brittany and a Paris Île-de-France and both had airports going to itally; then the a.citta for Paris would be the count of both Paris cities; which may not be the desired results. Without a unique identifier which describes a.citta on which we group this problem could persist. So maybe we need to group by a.citta and a.id_ap and display both in the select so the user knows "Which airport' we're talking about. Alternatively; I believe each airport is assigned a code defining it specifically; if that were tracked as part of the airport information; we could group on it and avoid the a.id_ap. City alone isn't enough to make a record unique.
Example:
SELECT a.citta, a.id_ap
FROM volo as v
INNER JOIN aereoporto as a
on a.id_ap = v.id_part
INNER JOIN aereoporto as b
on b.id_ap = v.id_arr
WHERE a.nazione = 'francia'
and b.nazione = 'italia'
GROUP BY a.citta, a.id_ap
HAVING count(v.id_volo) > 20 ;
I don't like using cross joins in the from clause which is the , notation in the from does. This style of join is from the 1980's and should be given up in favor of the explicit syntax of inner, left, right, full outer and cross join.
My reasoning for this is the FROM clause should define the tables being used and how they relate in most cases. The where clause should be used to limit the data being returned; mixing the two comes at a cost of confusion and more difficult maintenance long term. The only exception to this rule is outer join which may need to limit the data as part of the join to maintain the integrity of the outer join.
To address comment:
Something like this may work: if the total count of flights from a cities airport matches the count of arrivals coming from italia and destinations to italia then all flights are internal/domestic; otherwise do not show that airport. So the having clause like the where, acts as the filter to exclude cities with flights arriving from or departing to other countries. This approach is a bit more ambiguous on what it's doing but from a performance standpoint it should operate better than an in, not exists, or subqueries would given proper indexes on fields.
SELECT a.citta, a.id_ap
FROM volo as v
INNER JOIN aereoporto as a
on a.id_ap = v.id_part
INNER JOIN aereoporto as b
on b.id_ap = v.id_arr
GROUP BY a.citta, a.id_ap
HAVING count(v.id_volo) = sum(case when a.nazione = 'italia' then 1 else 0 end as ItalianArrivals)
and count(v.id_volo) = sum(case when b.nazione = 'italia' then 1 else 0 end as ItalianDepartures);
Given the ambiguity of the above, maintenance may be a bit harder for the next person so by using an explicit not exists once for arrivals and once for departures you can achieve the same results; but I do not believe it would be as optimal in performance... However, it too would achieve the proper results. I prefer not exists over not in when dealing with a data set that can grow in size to over 50 values. Since the query relates to a data set that looks like it would continue to grow, not exists seems like the 2nd best choice over the not in; with the having I believe being better performance on the larger datasets.

Answer 2

I tried hardly to figure out your example and what is the exact output you are trying to retrieve and I think the below shall help you.
SELECT a.citta
FROM aereoporto as a, volo as v
WHERE a.id_ap = v.id_part AND a.nazione = 'francia'
GROUP BY a.citta having count(*) > 20 ;
Mockup Data
aereoporto
id_ap citta nazione
1 rome italia
2 milan italia
3 paris francia
4 bordeaux francia
volo
id_volo data id_part oraPart id_arr oraArr tipoAereo
1 NULL 3 NULL 1 NULL NULL
2 NULL 3 NULL 1 NULL NULL
3 NULL 3 NULL 2 NULL NULL
4 NULL 4 NULL 2 NULL NULL
5 NULL 4 NULL 1 NULL NULL