faster way to retrieve parent values in SQL - sql

Question

Here is a description of my problem with dummy data:
I have a table in SQL Server as below:
Table
id parentid extid Isparent
0 a m 0
1 a m 1
2 a s 0
3 a s 0
4 b q 1
5 b z 0
for each group of records with the same parentid, there is only one record with Isparent = 1.
for each record, I want to find the extid of their parents.
So for id = 0, the parent record is id=1, and extid=m for id=1 is the value I need.
Here is the output I want.
childid parentid child_extid parent_extid
0 a m m
1 a m m
2 a s m
3 a s m
4 b q q
5 b z q
I'm doing this with a self join, but since the table is large, the performance is really slow, I also need to do this multiple times for a few different tables which makes things even worse.
SELECT
a.Id AS 'ChildId',
a.parentid As 'ParentId',
a.extid AS 'child_extid ',
b.extid AS 'parent_extid '
FROM Table a
LEFT JOIN Table b ON (a.parentid = b.parentid)
WHERE b.isparent = 1
Just wondering if there is a better way to do this.
Thanks!

Answer 1

This method of design is incredibly unorthodox. not only is this structure incapable of representing true hierarchy structures, but it also appears to represent a trinary relationship rather than a binary one. If you have control over the design of this data, and this was not your intent, I can help you reformat it for your intent if desired. Until then, this is a very basic representation of what you might be looking for, but falls short because there are unanswered questions about the intent of the data, such as what happens if you generate a row with the values ParentID = a, ExitID = y, IsParent = 1?
Having said that, here's a crack at it. Please note that this execution will be a self-semi join, and will require an index to work properly. This also excludes an order by clause because of the question above.
The code below will be in TSQL format until the DBMS is clarified.
CREATE FUNCTION ParentExitID (#ChildID INT)
AS
BEGIN
RETURN (
SELECT TOP 1 a.ParentID
FROM SampleTable A
WHERE EXISTS (
SELECT 1
FROM SampleTable B
WHERE A.ParentID = B.ParentID
AND A.IsParent = 1
AND B.ChildID = #ChildID
)
END

Answer 2

The "faster" way is to use a relational database, relationally and employ normalization in the design. What the question is demonstrating is cramming as much as possible into a table without any normalization and then building complex (and inefficient) querying logic on top of it.
create table #thing ( id int ); --id is PK
create table #ext ( id varchar(1) ); -- id is PK
create table #thingext ( thing int, ext varchar(1) ); -- thing,ext is PK
create table #parent ( id varchar(1), ext varchar(1)); -- id is PK, ext is FK
create table #thingparent ( thing int, parent varchar(1)); -- thing,parent is PK
insert into #thing values (0),(1),(2),(3),(4),(5);
insert into #ext values ('m'),('s'),('q'),('z');
insert into #thingext values (0,'m'),(1,'m'),(2,'s'),(3,'s'),(4,'q'),(5,'z');
insert into #parent values ('a','m'),('b','q');
insert into #thingparent values (0,'a'),(1,'a'),(2,'a'),(3,'a'),(4,'b'),(5,'b');
select t.id as childid, p.ext as extid
from #thing t
join #thingparent tp on t.id = tp.thing
join #parent p on tp.parent = p.id
What's getting jumbled up in the complexity of the original question is that extid is dependent upon the parent primary key but it is not dependent upon the child primary key. And a model has to reflect that.

Answer 3

Not sure if it would really speed it up.
But you can run this without a WHERE clause by putting that condition on b.isparent in the JOIN.
Example using a table variable:
declare #Table table (id int identity(0,1) primary key, parentid varchar(30), extid varchar(30), isparent bit);
insert into #Table (parentid, extid, isparent) values
('a','m',0),
('a','m',1),
('a','s',0),
('a','s',0),
('b','q',1),
('b','z',0);
SELECT
a.Id AS 'ChildId',
a.parentid AS 'ParentId',
a.extid AS 'child_extid',
b.extid AS 'parent_extid'
FROM #Table a
LEFT JOIN #Table b ON (a.parentid = b.parentid and b.isparent = 1);
But the Explain Plan will probably be the same as in your query.
Adding an non-unique index on parentid could speed things up.