Subquery's WHERE needs fields from main query - mysql

Question

have been struggling with this for the whole day and would like to ask for help how to make this query happen. My problem is that in INNER JOIN subquery's WHERE parts I need to use matching values from each GC table row being processed and obviously subquery doesnt know nothing about main query that's why it fails. Hopefully you'll catch the idea what i am trying to acomplish here:
SET #now=100; #sunix datetime
SELECT a.id, b.maxdate
FROM GC AS a
INNER JOIN (
SELECT 0 id_group, MAX(dt_active_to) AS maxdate
FROM GCDeals
WHERE dt_active_from > a.dt_lastused AND dt_active_from <= #now
GROUP BY id_group
UNION ALL
SELECT 1 id_group, MAX(dt_active_to) AS maxdate
FROM GCDeals
WHERE id_group <> 2 AND dt_active_from > a.dt_lastused AND dt_active_from <= #now
UNION ALL
SELECT 2 id_group, MAX(dt_active_to) AS maxdate
FROM GCDeals
WHERE id_group <> 1 AND dt_active_from > a.dt_lastused AND dt_active_from <= #now
GROUP BY id_group
) AS b
ON a.id_group = b.id_group
LEFT JOIN GCMsg AS c
ON a.id = c.id_gc
WHERE a.is_active = 1 AND a.dt_lastused < #now AND c.id_gc IS NULL
ORDER BY a.id
Thank you

Answer 1

Okay, I hope I have understood your original SQL now. You want all GC with the last appropriate max date. What you consider appropriate depends both on gc.dt_lastused and on gc.id_group. So rather than joining the tables together, you should select the max date per record in a subquery:
select id,
(
select max(dt_active_to)
from gcdeals
where dt_active_from > gc.dt_lastused and dt_active_from <= #now
and
(
gc.id_group = 0)
or
(gc.id_group = 1 and gcdeals.id_group <> 2)
or
(gc.id_group = 2 and gcdeals.id_group <> 1)
)
) as maxdate
from gc
where is_active = 1 and dt_lastused < #now
and id not in (select id_gc from gcmsg)
order by id;
EDIT: Here is the same statement using a join, offering to select max(dt_active_from) and min(dt_active_to) in one pass:
select gc.id, max(gcd.dt_active_from), min(gcd.dt_active_to)
from gc
left outer join gcdeals gcd
on gc.id = gcd.id_gc
and gcd.dt_active_from > gc.dt_lastused and gcd.dt_active_from <= #now
and
(
gc.id_group = 0)
or
(gc.id_group = 1 and gcd.id_group <> 2)
or
(gc.id_group = 2 and gcd.id_group <> 1)
)
where gc.is_active = 1 and gc.dt_lastused < #now
group by gc.id
order by gc.id;
You see, once you found out how to select the desired value in a subselect, it is not too hard to change it into a join. You get what you are looking for in two steps. If on the other hand you start with thinking in joins the same task can be quite abstract.
As to the execution plan: Say GC has 1000 active records and there are usually about 10 appropriate matches in GCDeals. Then the first statement selects 1,000 records and uses a loop on each record to access the GCDeals aggregate value. The second statement would just join 1,000 GC records with 10 GCDeals records each, thus getting 10,000 records, then aggregate them to make it 1,000 records again. Maybe the loops are faster, maybe the join. This depends. But, say, GC has one million active records and on each record you expect 1000 GCDeals matches, then the first statement may be quite slow having to loop so many times. But the second statement will create a billion intermediate records which can cause memory problems and either lead to very slow execution, too, or even lead to an unsufficient memory error. So it's just good to know that both techniques are available.