Sql query to get union of matching rows

Question

I want to write a sql query that shows union f all the [Type] for each [Key] if [Key] has atleast one [Type] in common and for non matched [Key]s it will return the row as it is.
For example In the sql table below [Key] '1' and '2' has [Type] 'B' in common and [Key] '1' and '4' has [Type] 'A' in common. In this case [Key] '1', '2' and '4' are related so result will be union of [Type]s in [Key]s '1', '2' and '4' which are 'A', 'B', 'C'
and 'E' for each [Key]. And [Key] '3' has no [Type] in common so it will return itself.
Input:
declare @categories table ([Key] int, [Type] Char(1))
insert into @categories ([Key], [Type]) values (1, 'A')
insert into @categories ([Key], [Type]) values (1, 'B')
insert into @categories ([Key], [Type]) values (2, 'B')
insert into @categories ([Key], [Type]) values (2, 'C')
insert into @categories ([Key], [Type]) values (3, 'D')
insert into @categories ([Key], [Type]) values (4, 'E')
insert into @categories ([Key], [Type]) values (4, 'A')
insert into @categories ([Key], [Type]) values (5, 'F')
insert into @categories ([Key], [Type]) values (5, 'G')
insert into @categories ([Key], [Type]) values (6, 'G')
insert into @categories ([Key], [Type]) values (6, 'H')
Desired output:
Key Type
1 A
1 B
1 C
1 E
2 A
2 B
2 C
3 D
4 A
4 B
4 E
5 F
5 G
5 H
6 F
6 G
6 H

Answer 1

  
The data element names are wrong. KEY is a reserved word; “Categories" and "type" are called attribute properties in ISO-11179 rules. Matthias Kläy is right; this is a graph problem in disguise, but you can do it with set theory to get  what are called
equivalence classes. 
An edge in a graph has two nodes. Some authors allow a single node to count as a edge, but a better way is to put the same node on both ends of the edge. Here is the graph in a table with all the needed constraints. This is why you should post DDL and not be
so rude.  
DROP TABLE Graph;
CREATE TABLE Graph
(edge INTEGER NOT NULL,
 node_1 CHAR(1) NOT NULL,
 node_2 CHAR(1) NOT NULL,
 CHECK (node_1 <= node_2),
 PRIMARY KEY (node_1, node_2));
Here is your data in the correct format. 
INSERT INTO Graph 
VALUES 
 (1, 'A', 'B'),
 (2, 'B', 'C'),
 (3, 'D', 'D'), -- orphan node
 (4, 'A', 'E'),
 (5, 'F', 'G'),
 (6, 'G', 'H');
Now Google Warshall's Algorithm. It uses three nested loops and an adjacency array. This is very clean and fast in a procedural language. Not so much in SQL. Let us do this in steps:
WITH X1 (edge, node1_1, node1_2, node2_1, node2_2 )
AS
(SELECT CASE WHEN G1.edge <> G2.edge 
       THEN G1.edge ELSE G2.edge END,
       G1.node_1, G1.node_2, 
       G2.node_1, G2.node_2       
  FROM Graph AS G1, Graph AS G2
 WHERE G1.node_1 IN (G2.node_1, G2.node_2) 
   AND G1.edge <> G2.edge),
X2 (edge, node_1, node_2)
AS
(SELECT edge, 
CASE WHEN node1_1 IN (node2_1, node2_2) THEN node1_2 ELSE node1_1 END,
CASE WHEN node2_1 IN (node1_1, node1_2) THEN node2_2 ELSE node2_1 END
FROM X1)
SELECT DISTINCT edge,
       CASE WHEN node_1 < node_2 THEN node_1 ELSE node_2 END,
       CASE WHEN node_2 < node_1 THEN node_1 ELSE node_2 END
 FROM X2;
The X1 subquery gets the paths of length two. The X2 subquery removes the middle node and creates a new sorted edge. Insert these new rows into Graphs, if they are not there. Repeat the process until no more rows are added. 
DROP TABLE Graph;
CREATE TABLE Graph
(edge INTEGER NOT NULL,
 node_1 CHAR(1) NOT NULL,
 node_2 CHAR(1) NOT NULL,
 CHECK (node_1 <= node_2),
 PRIMARY KEY (node_1, node_2));
INSERT INTO Graph 
VALUES 
 (1, 'A', 'B'),
 (2, 'B', 'C'),
 (3, 'D', 'D'), -- orphan node
 (4, 'A', 'E'),
 (5, 'F', 'G'),
 (6, 'G', 'H');
Here is the monster rolled up into a single statement. 
INSERT INTO Graph
SELECT DISTINCT edge,
       CASE WHEN node_1 < node_2 THEN node_1 ELSE node_2 END,
       CASE WHEN node_2 < node_1 THEN node_1 ELSE node_2 END
 FROM (SELECT edge, 
CASE WHEN node1_1 IN (node2_1, node2_2) THEN node1_2 ELSE node1_1 END,
CASE WHEN node2_1 IN (node1_1, node1_2) THEN node2_2 ELSE node2_1 END
FROM 
(SELECT CASE WHEN G1.edge < G2.edge 
       THEN G1.edge ELSE G2.edge END,
       G1.node_1, G1.node_2, 
       G2.node_1, G2.node_2       
  FROM Graph AS G1, Graph AS G2
 WHERE G1.node_1 IN (G2.node_1, G2.node_2) 
   AND G1.edge <> G2.edge) AS X1(edge,node1_1, node1_2, node2_1, node2_2) )
    AS X2(edge, node_1, node_2)
EXCEPT 
 SELECT * FROM Graph;
 SELECT * FROM Graph ORDER BY edge, node_1, node_2;
1 A B
1 A C
1 B E
1 C E
2 B C
3 D D
4 A E
5 F G
5 F H
6 G H
--CELKO-- Books in Celko Series for Morgan-Kaufmann Publishing: Analytics and OLAP in SQL / Data and Databases: Concepts in Practice Data / Measurements and Standards in SQL SQL for Smarties / SQL Programming Style / SQL Puzzles and Answers / Thinking
in Sets / Trees and Hierarchies in SQL