仅在计数大于1时进行联接

Question

I wonder if the following a bit contrived example is possible without using intermediary variables and a conditional clause.

Consider an intermediary query which can produce a result set that contain either no rows, one row or multiple rows. Most of the time it produces just one row, but when multiple rows, one should join the resulting rows to another table to prune it down to either one or no rows. After this if there is one row (as opposed to no rows), one would want to return multiple columns as produced by the original intermediary query.

I have in my mind something like following, but it won't obviously work (multiple columns in switch-case, no join etc.), but maybe it illustrates the point. What I would like to have is to just return what is currently in the SELECT clause in case @@ROWCOUNT = 1 or in case it is greater, do a INNER JOIN to Auxilliary , which prunes down x to either one row or no rows and then return that. I don't want to search Main more than once and Auxilliary only when x here contains more than one row.

SELECT x.MainId, x.Data1, x.Data2, x.Data3,
CASE         
     WHEN @@ROWCOUNT IS NOT NULL AND @@ROWCOUNT = 1 THEN
        1
     WHEN @@ROWCOUNT IS NOT NULL AND @@ROWCOUNT > 1 THEN
        -- Use here @id or MainId to join to Auxilliary and there 
        -- FilteringCondition = @filteringCondition to prune x to either 
        -- one or zero rows.
END         
FROM
(
    SELECT
        MainId,
        Data1,
        Data2,
        Data3
    FROM Main
    WHERE
        MainId = @id
) AS x;

CREATE TABLE Main
(
    -- This Id may introduce more than row, so it is joined to
    -- Auxilliary for further pruning with the given conditions.
    MainId INT,
    Data1 NVARCHAR(MAX) NOT NULL,
    Data2 NVARCHAR(MAX) NOT NULL,
    Data3 NVARCHAR(MAX) NOT NULL,

    AuxilliaryId INT NOT NULL
);


CREATE TABLE Auxilliary
(
    AuxilliaryId INT IDENTITY(1, 1) PRIMARY KEY,
    FilteringCondition NVARCHAR(1000) NOT NULL
);

Would this be possible in one query without a temporary table variable and a conditional? Without using a CTE?

Some sample data would be

INSERT INTO Auxilliary(FilteringCondition)
VALUES
    (N'SomeFilteringCondition1'),
    (N'SomeFilteringCondition2'),
    (N'SomeFilteringCondition3');


INSERT INTO Main(MainId, Data1, Data2, Data3, AuxilliaryId)
VALUES
    (1, N'SomeMainData11', N'SomeMainData12', N'SomeMainData13', 1),
    (1, N'SomeMainData21', N'SomeMainData22', N'SomeMainData23', 2),
    (2, N'SomeMainData31', N'SomeMainData32', N'SomeMainData33', 3);

And a sample query, which actually behaves as I'd like it to behave with the caveat I'd want to do the join only if querying Main directly with the given ID produces more than one result.

DECLARE @id AS INT = 1;
DECLARE @filteringCondition AS NVARCHAR(1000) = N'SomeFilteringCondition1';

SELECT *
FROM
    Main
    INNER JOIN Auxilliary AS aux ON aux.AuxilliaryId = Main.AuxilliaryId
WHERE MainId = @id AND aux.FilteringCondition = @filteringCondition;

Answer 1

You don't usually use a join to reduce the result set of the left table. To limit a result set you'd use the where clause instead. In combination with another table this would be WHERE [NOT] EXISTS .

So let's say this is your main query:

select * from main where main.col1 = 1;

It returns one of the following results:

• no rows, then we are done
• one row, then we are also done
• more than one row, then we must extend the where clause

The query with the extended where clause:

select * from main where main.col1 = 1
and exists (select * from other where other.col2 = main.col3);

which returns one of the following results:

• no rows, which is okay
• one row, which is okay
• more than one row - you say this is not possible

So the task is to do this in one step instead. I count records and look for a match in the other table for every record. Then ...

• if the count is zero we get no result anyway
• if it is one I take that row
• if it is greater than one, I take the row for which exists a match in the other table or none when there is no match

Here is the full query:

select *
from
(
  select
    main.*,
    count(*) over () as cnt,
    case when exists (select * from other where other.col2 = main.col3) then 1 else 0 end
     as other_exists
  from main 
  where main.col1 = 1
) counted_and_checked
where cnt = 1 or other_exists = 1;

UPDATE: I understand that you want to avoid unnecessary access to the other table. This is rather difficult to do however.

In order to only use the subquery when necessary, we could move it outside:

select *
from
(
  select
    main.*,
    count(*) over () as cnt
  from main 
  where main.col1 = 1
) counted_and_checked
where cnt = 1 or exists (select * from other where other.col2 = main.col3);

This looks much better in my opinion. However there is no precedence among the two expressions left and right of an OR . So the DBMS may still execute the subselect on every record before evaluating cnt = 1 .

The only operation that I know of using left to right precedence, ie doesn't look further once a condition on the left hand side is matched is COALESCE . So we could do the following:

select *
from
(
  select
    main.*,
    count(*) over () as cnt
  from main 
  where main.col1 = 1
) counted_and_checked
where coalesce( case when cnt = 1 then 1 else null end , 
                (select count(*) from other where other.col2 = main.col3) 
              ) > 0;

This may look a bit strange, but should prevent the subquery from being executed, when cnt is 1.

Answer 2

You may try something like

select * from  Main m
where mainId=@id 
and @filteringCondition = case when(select count(*) from Main m2 where m2.mainId=@id) >1 
then (select filteringCondition from Auxilliary a where a.AuxilliaryId = m.AuxilliaryId) else @filteringCondition end

but it's hardly very fast query. I'd better use temp table or just if and two queries.