How to improve simple but inefficient parent/child relationship query - sql

Question

I have a simple table as described below, where there's a possible parent/child relationship. This is actually a very large table, but this is an fair representation. There are no "grandchildren" relationships.
I need to transform this into a slightly different table which is filtered on some input value.
declare #pc table ( myId char(1) not null, parentId char(1) );
insert into #pc (myId, parentId) values ('A', null)
insert into #pc (myId, parentId) values ('B', 'A')
insert into #pc (myId, parentId) values ('C', 'A')
insert into #pc (myId, parentId) values ('D', null)
insert into #pc (myId, parentId) values ('E', null)
insert into #pc (myId, parentId) values ('F', 'E')
insert into #pc (myId, parentId) values ('G', null)
insert into #pc (myId, parentId) values ('H', 'G')
insert into #pc (myId, parentId) values ('I', 'G')
insert into #pc (myId, parentId) values ('J', 'G')
insert into #pc (myId, parentId) values ('K', null)
-- This is the results I need
declare #target table ( myId char(1) not null, parentId char(1), hasFamily bit );
Given input of "A", then I need three rows like this:
A NULL 1
B A 1
C A 1
In other words, I need everything that belongs to the "family group" A.
Given "B" I need the same output, everything in B's family group (which happens to be A's):
A NULL 1
B A 1
C A 1
Given "D" I need just the one line since no-one is in D's family:
D NULL 0
Given null, I need the entire table data set but with the proper rows marked as "having family" or not.
Here's my attempt which is technically correct, but it's not efficient at all taking 3 passes at the data to do it:
declare #testcase char(1) = 'B';
-- The inefficient method
INSERT INTO #target( myId,parentId )
SELECT pc.myId, pc.parentId
FROM #pc pc
WHERE(pc.myId = ISNULL(#testcase, pc.myId))
OR (pc.parentId =#testcase);
INSERT INTO #target( myId,parentId )
SELECT pc.myId, pc.parentId
FROM #pc pc
WHERE pc.myId IN ( SELECT parentId FROM #target )
AND pc.myId NOT IN ( SELECT myId FROM #target );
update t
set t.hasFamily = 1
from #target t
left outer join #target t2
on t.myId = t2.parentId
where t.parentId is not null or t2.myId is not null;
Can you see a better way of looking at this problem?

Answer 1

A window function to count children, made available on every row, simplifies the wanted queries. How you chose to deploy it is u to you. You might choose to use persisted computed columns for example, or triggers. If scale and performance are issues then you would need to consider the indexing and inspect execution plans.
Perhaps I don't see the complexity from the small model you have presented here hence my suggestions may be too simplistc.
Demo at SQL Fiddle
create table Table1 ( myId char(1) not null, parentId char(1) );
insert into Table1 (myId, parentId) values ('A', null);
insert into Table1 (myId, parentId) values ('B', 'A');
insert into Table1 (myId, parentId) values ('C', 'A');
insert into Table1 (myId, parentId) values ('D', null);
insert into Table1 (myId, parentId) values ('E', null);
insert into Table1 (myId, parentId) values ('F', 'E');
insert into Table1 (myId, parentId) values ('G', null);
insert into Table1 (myId, parentId) values ('H', 'G');
insert into Table1 (myId, parentId) values ('I', 'G');
insert into Table1 (myId, parentId) values ('J', 'G');
insert into Table1 (myId, parentId) values ('K', null);
create view too_simplistic as
select
myId
, parentId
, coalesce(parentId, myId) parent_flat
, case when count(*) over(partition by coalesce(parentId, myId))-1 = 0
then 0
else 1
end as hasFamily
from table1
;
Query 1:
declare #want char(1) = 'A'
select myId, parentId, hasFamily
from too_simplistic
where parent_flat = (select parent_flat from too_simplistic where MyId = #want)
or MyId = #want
Results:
| myId | parentId | hasFamily |
|------|----------|-----------|
| A | (null) | 1 |
| B | A | 1 |
| C | A | 1 |
Query 2:
declare #want char(1) = 'B'
select myId, parentId, hasFamily
from too_simplistic
where parent_flat = (select parent_flat from too_simplistic where MyId = #want)
or MyId = #want
Results:
| myId | parentId | hasFamily |
|------|----------|-----------|
| A | (null) | 1 |
| B | A | 1 |
| C | A | 1 |
Query 3:
declare #want char(1) = 'D'
select myId, parentId, hasFamily
from too_simplistic
where parent_flat = (select parent_flat from too_simplistic where MyId = #want)
or MyId = #want
Results:
| myId | parentId | hasFamily |
|------|----------|-----------|
| D | (null) | 0 |
Query 4:
select *
from too_simplistic
Results:
| myId | parentId | parent_flat | hasFamily |
|------|----------|-------------|-----------|
| A | (null) | A | 1 |
| B | A | A | 1 |
| C | A | A | 1 |
| D | (null) | D | 0 |
| E | (null) | E | 1 |
| F | E | E | 1 |
| G | (null) | G | 1 |
| H | G | G | 1 |
| I | G | G | 1 |
| J | G | G | 1 |
| K | (null) | K | 0 |
select d.*
, case when children = 0 then 0 else 1 end as hasFamily
from (
select *
, count(*) over(partition by coalesce(parentId, myId))-1 children
from #pc
) d
;