子查询选择语句vs内部联接

Question

I'm confused about these two statements who's faster and more common to use and best for memory

select p.id, p.name, w.id, w.name 
from person p 
inner join work w on w.id = p.wid 
where p.id in (somenumbers)
vs

select p.id, p.name, (select id from work where id=p.wid) , (select name from work where id=p.wid)
from person p 
where p.id in (somenumbers)

The whole idea of this is that if I have I huge database and I want to make inner join it will take memory and less performance to johin work table and person table but the sub query select statments it will only select one statment at the time so which is the best here

Answer 1

First, the two queries are not the same. The first filters out any rows that have no matching rows in work .

The equivalent first query uses a left join :

select p.id, p.name, w.id, w.name 
from person p left join
     work w
     on w.id = p.wid 
where p.id in (somenumbers);

Then, the second query can be simplified to:

select p.id, p.name, p.wid,
       (select name from work where w.id = p.wid)
from person p 
where p.id in (somenumbers);

There is no reason to look up the id in work when it is already present in person .

If you want optimized queries, then you want indexes on person(id, wid, name) and work(id, name) .

With these indexes, the two queries should have basically the same performance. The subquery will use the index on work for fetching the rows from work and the where clause will use the index on person . Either query should be fast and scalable.

Answer 2

The subqueries in your second example will execute once for every row , which will perform badly. That said, some optimizers may be able to convert it to a join for you - YMMV.

A good rule to follow in general is: much prefer joins to subqueries.

Answer 3

joins give better performance as comparison with sub-query .if there is join on Int column or have index on join column gives best performance .

select p.id, p.name, w.id, w.name 
from person p 
inner join work w on w.id = p.wid 
where p.id in (somenumbers)

Answer 4

It really depends on how you want to optimaze the query (includie but not limited to add/removing/reordering the index),

I found the setup which makes join soars might let subquery suffer, the opposite may also be true. Thus there is not that much point to compare them with the same setup.

I choose to use and optimize with join. In my experince join at its best condition setup, rarely loses to subquery, but a lot eaiser to read.

When the vendor stuff an extreme load of queries with subqueries to the system. Unless the performance start to crawl, due to my other work's query optimization, it simply doesn't worth the effort to change them.