How to compare n:m assignments? - sql

Question

I have two tables (entity and kind) plus a n:m table (entity_kind).
CREATE TABLE
entity
(
entity_id INT
, name NVARCHAR(100)
, PRIMARY KEY(entity_id)
)
CREATE TABLE
kind
(
kind_id INT
, name NVARCHAR(100)
, PRIMARY KEY(kind_id)
)
CREATE TABLE
entity_kind
(
entity_id INT
, kind_id INT
, PRIMARY KEY(entity_id, kind_id)
)
Test data:
INSERT INTO
entity
VALUES
(1, 'Entity A')
, (2, 'Entity B')
, (3, 'Entity C')
INSERT INTO
kind
VALUES
(1, 'Kind 1')
, (2, 'Kind 2')
, (3, 'Kind 3')
, (4, 'Kind 4')
INSERT INTO
entity_kind
VALUES
(1, 1)
, (1, 3)
, (2, 1)
, (2, 2)
, (3, 4)
My code so far:
DECLARE
#selected_entities
TABLE
(
entity_id INT
)
DECLARE
#same_kinds BIT;
INSERT INTO
#selected_entities
VALUES
(1), (2)
-- Missing code here
SELECT
#same_kinds AS "same_kinds"
The table var #selected_entities is filled with entities that should be compared.
The logical var #same_kinds should indicate whether the selected entities have exactly the same kinds assigned.
How can I achieve this?

Answer 1

This is a compare two sets of things type problem. The query I'm going to show gives all pairs along with a flag. You can easily incorporate comparing a subquery by changing the first two entity tables to the table of ids you want to compare.
This query has a few parts. First, it produces all pairs of entities from the entity tables. This is important, because this will pick up even entities that have no "kinds" associated with them. You want a flag, rather than just a list of those that match.
Then the heart of the logic is to do a self-join on the entity-kinds table with the match on "kind". This is then aggregated by the two entities. The result is a count of the kinds that two entities share.
The final logic is to compare this count to the count of "kinds" on each entity. If all of these counts are the same, then the entities match. If not, they do not. This approach does assume that there are no duplicates in entity_kinds.
select e1.entity_id as e1, e2.entity_id as e2,
(case when count(ek1.entity_id) = max(ek1.numkinds) and
count(ek2.entity_id) = count(ek1.entity_id) and
max(ek1.numkinds) = max(ek2.numkinds)
then 1
else 0
end) as IsSame
from entity e1 join
entity e2
on e1.entity_id < e2.entity_id left outer join
(select ek.*, count(*) over (partition by entity_id) as numkinds
from entity_kind ek
) ek1
on e1.entity_id = ek1.entity_id left outer join
(select ek.*, count(*) over (partition by entity_id) as numkinds
from entity_kind ek
) ek2
on e2.entity_id = ek2.entity_id and
ek2.kind_id = ek1.kind_id
group by e1.entity_id, e2.entity_id;
The SQL Fiddle is here.

Answer 2

You can do this with two checks: First, if the kind-count on each entity is not the same, then they cannot match. Second, provided the count is the same, you just need to find one kind that doesn't match the list of an arbitrary other entity (I just take the first entity in the compare list). In code:
DECLARE #firstEntity int = (SELECT TOP 1 entity_id from #selected_entities)
IF EXISTS(SELECT TOP 1 se.entity_id FROM #selected_entities se
INNER JOIN entity_kind ek ON ek.entity_id = se.entity_id
WHERE ek.kind_id NOT IN (SELECT kind_id from entity_kind where entity_id = #firstEntity)
OR ((SELECT COUNT(1) FROM entity_kind WHERE entity_id = ek.entity_id)
<> (SELECT COUNT(1) FROM entity_kind WHERE entity_id = #firstEntity)))
SET #same_kinds = 0
ELSE
SET #same_kinds = 1

Answer 3

DECLARE #first_entity_id INT;
SET #first_entity_id = (SELECT TOP(1) se.entity_id FROM #selected_entities se);
DECLARE #dummyvar INT;
SELECT DISTINCT #dummyvar = COUNT(ek.kind_id)
FROM dbo.entity_kind ek
LEFT JOIN (
SELECT ek.kind_id
FROM dbo.entity_kind ek
WHERE ek.entity_id = #first_entity_id
) k ON ek.kind_id = k.kind_id
WHERE ek.entity_id IN (SELECT se.entity_id FROM #selected_entities se)
GROUP BY ek.entity_id;
SET #same_kinds = CASE WHEN ##ROWCOUNT = 1 THEN 1 ELSE 0 END;
SELECT #same_kinds AS [#same_kinds];
Note: #selected_entities should be declared thus:
DECLARE
#selected_entities
TABLE
(
entity_id INT PRIMARY KEY
)