子查询与联接计数同一表中的子表以及其他表中的子表时

Question

CREATE TABLE [dbo].[Comment] 
(
  [Id] [int] IDENTITY(1,1) NOT NULL,
  [UserId] [int] NOT NULL,
  [Comment] [nvarchar](1024) NOT NULL,
  [Created] [datetime] NOT NULL CONSTRAINT [DF_Comment_Created]  DEFAULT (getdate()),
  [ContentId] [int] NOT NULL,
  [ParentId] [int] NULL,
  CONSTRAINT [PK_Comment] PRIMARY KEY CLUSTERED 
  (
    [Id] ASC
  )WITH (PAD_INDEX = OFF, STATISTICS_NORECOMPUTE = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS = ON, ALLOW_PAGE_LOCKS = ON) ON [PRIMARY]
  ) ON [PRIMARY]

CREATE TABLE [dbo].[CommentLike]
(
  [CommentId] [int] NOT NULL,
  [UserId] [int] NOT NULL,
  CONSTRAINT [PK_CommentLike] PRIMARY KEY CLUSTERED 
  (
    [CommentId] ASC,
    [UserId] ASC
  )WITH (PAD_INDEX = OFF, STATISTICS_NORECOMPUTE = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS = ON, ALLOW_PAGE_LOCKS = ON) ON [PRIMARY]
  ) ON [PRIMARY]

CREATE TABLE [dbo].[User]
(
  [Id] [int] IDENTITY(1,1) NOT NULL,
  [Username] [nvarchar](64) NOT NULL,
  [FirstName] [nvarchar](50) NOT NULL,
  [LastName] [nvarchar](50) NOT NULL,
  [Email] [nvarchar](255) NOT NULL,
CONSTRAINT [PK_User] PRIMARY KEY CLUSTERED 
(
  [Id] ASC
)WITH (PAD_INDEX = OFF, STATISTICS_NORECOMPUTE = OFF, IGNORE_DUP_KEY =  OFF, ALLOW_ROW_LOCKS = ON, ALLOW_PAGE_LOCKS = ON) ON [PRIMARY]
) ON [PRIMARY]

There is a non clustered index on Comment (ContentId, ParentId) .

In short the Comment table contains comments and sub comments via Id and ParentId . The CommentLike table contains likes (one like per user) for comments and sub comments.

The Comment table contains about 8000 rows and the CommentLike table 1800.

I´ve created a query that lists comments (only top level comments), sub comment count, like count and also a value that indicates if supplied user likes each comment. The whole query is filtered on ContentId in the where clause (simply a unique integer value that represents an id in another system)

I have one version that uses sub queries and the other joins (on sub queries).

Sub query version:

select 
  c.Id,
  c.Comment,
  c.Created,
  c.ContentId,
  (select count(Id) from Comment where ParentId = c.Id) as SubComments,
  (select count(UserId) from CommentLike where CommentId = c.Id) as Likes,
  (select count(UserId) from CommentLike where CommentId = c.Id and UserId = @currentUserId) as CurrentUserIsLiking
from Comment c
where c.ContentId = @contentId and c.ParentId is null
group by
  c.Id, c.Comment, c.Created, c.ContentId

Join version:

select
  c.Id,
  c.Comment,
  c.Created,
  c.ContentId,
  isnull(c2.SubComments, 0) as SubComments,
  isnull(cl.Likes, 0) as Likes,
  isnull(cl.CurrentUserIsLiking, 0) as CurrentUserIsLiking
from Comment c
left join
(
  select
    ParentId,
    count(Id) as SubComments
  from Comment 
  group by ParentId
) as c2
on c.Id = c2.ParentId
left join
(
  select
    CommentId,
    count(UserId) as Likes,
    count(case when UserId = @currentUserId then 1 else null end) as CurrentUserIsLiking
  from CommentLike 
  group by CommentId
) as cl
on c.Id = cl.CommentId
where c.ContentId = @contentId and c.ParentId is null
group by
  c.Id, c.Comment, c.Created, c.ContentId, 
  c2.SubComments, cl.Likes, cl.CurrentUserIsLiking

On average both versions run below 600ms but the sub query version always seems to run about 20% faster than the join version.

The question:

No matter how many rows the tables contain the sub query version is always faster than the join version. I've always thought that, performance wise, joins are better than sub queries, is that not true in this case? Since performance is important I wonder if there is any optimization that can be done to either of the versions to make that specific version outperform the other?

Answer 1

Why are you aggregating in the outer query for the join version?

select c.*, 
       p.SubComments,
       coalesce(cl.Likes, 0) as Likes,
       coalesce(cl.CurrentUserIsLiking, 0) as CurrentUserIsLiking
from Comment c left join
     (select ParentId, count(*) as SubComments
      from Comment
      group by ParentId
     ) p
     on p.ParentId = c.Id
     (select CommentId, count(UserId) as Likes,
             sum(case when UserId = @currentUserId then 1 else 0
                 end) as CurrentUserIsLiking
     from CommentLike 
     group by CommentId
    ) cl
    on c.Id = cl.CommentId
where c.ContentId = @contentId and c.ParentId is null;

Because the outer query is limiting the comments, it is quite reasonable that the version using correlated subqueries would be faster.