Implementazione di una query ricorsive in SQL

Question

Ho una domanda circa l'uso di SQL ricorsivo in cui ho seguito la struttura della tabella

prodotti possono essere in più gruppi (per ragioni di chiarezza, non sto usando int)

CREATE TABLE ProductGroups(ProductName nvarchar(50), GroupName nvarchar(50)) 

INSERT INTO ProductGroups(ProductName, GroupName) values 
('Product 1', 'Group 1'), 
('Product 1', 'Group 2'), 
('Product 2', 'Group 1'), 
('Product 2', 'Group 6'), 
('Product 3', 'Group 7'), 
('Product 3', 'Group 8'), 
('Product 4', 'Group 6') 


+-----------+---------+ 
| Product | Group | 
+-----------+---------+ 
| Product 1 | Group 1 | 
| Product 1 | Group 2 | 
| Product 2 | Group 1 | 
| Product 2 | Group 6 | 
| Product 3 | Group 7 | 
| Product 3 | Group 8 | 
| Product 4 | Group 6 | 
+-----------+---------+ 

Ora la domanda è voglio scoprire tutti i relativi prodotti in modo cioè se mi passa prodotto 1 poi ho bisogno il seguente risultato

+-----------+---------+ 
| Product | Group | 
+-----------+---------+ 
| Product 1 | Group 1 | 
| Product 1 | Group 2 | 
| Product 2 | Group 1 | 
| Product 2 | Group 6 |  
| Product 4 | Group 6 | 
+-----------+---------+ 

Quindi, fondamentalmente voglio prima scoprire tutti i gruppi per il prodotto 1 e quindi per ogni gruppo voglio scoprire tutti i prodotti e così via ...

1. prodotto 1 => Gruppo 1 , Gruppo 2;
2. Gruppo 1 => Prodotto 1, Prodotto 2 (il Gruppo 1 e il Prodotto 1 esistono già, quindi dovrebbero essere evitati altrimenti andrebbero nel ciclo infinito );
3. Gruppo 2 => Prodotto 1 (esiste già come sopra);
4. prodotto 2 => Gruppo 1, Gruppo 6 (Gruppo 1 e 2 del prodotto già esistono)
5. Gruppo 6 => prodotto 4

Answer 1

non credo che questo è possibile con un CTE ricorsiva, perché ti è consentito solo un riferimento ricorsivo per definizione ricorsiva.

sono riuscito a realizzarlo con un while ciclo, che rischia di essere meno efficiente rispetto al CTE:

declare @related table (ProductName nvarchar(50), GroupName nvarchar(50)) 

-- base case 
insert @related select * from ProductGroups where ProductName='Product 1' 

-- recursive step 
while 1=1 
begin 

    -- select * from @related -- uncomment to see progress 

    insert @related select p.* 
    from @related r 
    join ProductGroups p on p.GroupName=r.GroupName or p.ProductName=r.ProductName 
    left join @related rr on rr.ProductName=p.ProductName and rr.GroupName=p.GroupName 
    where rr.ProductName is null   

    if @@ROWCOUNT = 0 
     break; 

end 

select * from @related 

Si dovrebbe fare attenzione a quanto sopra - punto di riferimento su dati reali dimensioni prima della distribuzione!

Answer 2

Questo non sarà facile. Stai modellando equivalence classes. SQL è un insieme langauge, e si sta guardando una classe - un insieme di insiemi:

https://www.simple-talk.com/sql/t-sql-programming/the-sql-of-membership-equivalence-classes--cliques/

Answer 3

Esso può essere fatto con una query ricorsive, ma non è ottimale perché SQL Server non consente di fare riferimento a la tabella ricorsiva come un insieme. Quindi finisci per dover mantenere una stringa di percorso per evitare loop infiniti. Se si utilizzano ints, è possibile sostituire la stringa del percorso con un hierarchyid.

with r as (
    select ProductName Root, ProductName, GroupName, convert(varchar(max), '/') Path from ProductGroups 
    union all 
    select r.Root, pg.ProductName, pg.GroupName, convert(varchar(max), r.Path + r.ProductName + ':' + r.GroupName + '/') 
    from r join ProductGroups pg on pg.GroupName=r.GroupName or pg.ProductName=r.ProductName 
    where r.Path not like '%' + pg.ProductName + ':' + pg.GroupName + '%' 
) 

select distinct ProductName, GroupName from r where Root='Product 1' 

http://sqlfiddle.com/#!3/a65d1/5/0

Answer 4

Si può fare questo.

DECLARE @ProductGroups AS TABLE (
     ProductName NVARCHAR(50) , 
     GroupName NVARCHAR(50) 
     ) 

INSERT INTO @ProductGroups 
     (ProductName, GroupName) 
VALUES ('Product 1', 'Group 1'), 
     ('Product 1', 'Group 2'), 
     ('Product 2', 'Group 1'), 
     ('Product 2', 'Group 6'), 
     ('Product 3', 'Group 7'), 
     ('Product 3', 'Group 8'), 
     ('Product 4', 'Group 6'); 
; 
WITH cte 
      AS (SELECT a.ProductName 
       FROM  @ProductGroups a 
       WHERE a.GroupName IN (SELECT x.GroupName 
             FROM @ProductGroups x 
             WHERE x.ProductName = 'Product 1') 
      ), 
     cte2 
      AS (SELECT GroupName 
       FROM  @ProductGroups 
       WHERE ProductName IN (SELECT x.ProductName 
             FROM cte x) 
      ) 
    SELECT * 
    FROM @ProductGroups 
    WHERE GroupName IN (SELECT x.GroupName 
          FROM  cte2 x)