如何使用多个表优化SQL查询

Question

I have this SQL query here that grabs the 5 latest news posts. I want to make it so it also grabs the total likes and total news comments in the same query. But the query I made seems to be a little slow when working with large amounts of data so I am trying to see if I can find a better solution. Here it is below:

SELECT *, 
`id` as `newscode`, 
(SELECT COUNT(*) FROM `likes` WHERE `type`="newspost" AND `code`=`newscode`) as `total_likes`,
(SELECT COUNT(*) FROM `news_comments` WHERE `post_id`=`newscode`) as `total_comments`
FROM `news` ORDER BY `id` DESC LIMIT 5

Here is a SQLFiddle as well: http://sqlfiddle.com/#!2/d3ecbf/1

Answer 1

I would recommend adding a total_likes and total_comments fields to the news table which gets incremented/decremented whenever a like and/or comment is added or removed.

Your likes and news_comments tables should be used for historical purposes only.

This strenuous counting should not be performed every time a page is loaded because that is a complete waste of resources.

Answer 2

首先检查ID ， post_id和type，code列的帮助索引。

Answer 3

I assume this is T-SQL, as that is what I am most familiar with.

First I would check indexes. If that looks good, then I'd check statement. Take a look at your query map to see how it's populating your result.

SQL works backward, so it starts with your last AND statement and goes from there. It'll group them all by code, and then type, and finally give you a count.

Right now, you're grabbing everything with certain codes, regardless of date. When you stated that you want the latest, I assume there is a date column somewhere.

In order to speed things up, add another AND to your WHERE and account for the date. Either last 24 hours, last week, whatever.

Answer 4

You could rewrite this using joins, MySQL has known issues with subqueries, especially when dealing with large data sets:

SELECT  n.*, 
        `id` as `newscode`, 
        COALESCE(l.TotalLikes, 0) AS `total_likes`,
        COALESCE(c.TotalComments, 0) AS `total_comments`
FROM    `news` n
        LEFT JOIN
        (   SELECT  Code, COUNT(*) AS TotalLikes
            FROM    `likes` 
            WHERE   `type` = "newspost" 
            GROUP BY Code
        ) AS l
            ON l.`code` = n.`id`
        LEFT JOIN
        (   SELECT  post_id, COUNT(*) AS TotalComments
            FROM    `news_comments` 
            GROUP BY post_id
        ) AS c
            ON c.`post_id` = n.`id`
ORDER BY n.`id` DESC LIMIT 5;

The reason is that when you use a join as above, MySQL will materialise the results of the subquery when it is first needed, eg at the start of this query, mySQL will put the results of:

SELECT  post_id, COUNT(*) AS TotalComments
FROM    `news_comments` 
GROUP BY post_id

into an in memory table and hash post_id for faster lookups. Then for each row in news it only has to look up TotalComments from this hashed table, when you use a correlated subquery it will execute the query once for each row in news , which when news is large will result in a large number of executions. If the initial result set is small you may not see a performance benefit and it may be worse.

Examples on SQL Fiddle

Finally, you may want to index the relevant fields in news_comments and likes . For this particular query I think the following indexes will help:

CREATE INDEX IX_Likes_Code_Type ON Likes (Code, Type);
CREATE INDEX IX_newcomments_post_id ON news_comments (post_id);

Although you may need to split the first index into two:

CREATE INDEX IX_Likes_Code ON Likes (Code);
CREATE INDEX IX_Likes_Type ON Likes (Type);