TSQL CTE: come evitare l'attraversamento circolare?

Question

Ho scritto un'espressione CTE molto semplice che recupera un elenco di tutti i gruppi di cui un utente è membro.

Le regole sono le seguenti: un utente può trovarsi in più gruppi e i gruppi possono essere nidificati in modo che un gruppo possa essere membro di un altro gruppo e inoltre i gruppi possono essere membri reciproci di un altro, quindi il gruppo A è un membro della B Group e del Gruppo B è anche un membro del gruppo A.

mio CTE va come questa e, ovviamente, produce una ricorsione infinita:

  ;WITH GetMembershipInfo(entityId) AS(-- entity can be a user or group 
       SELECT k.ID as entityId FROM entities k WHERE k.id = @userId 
       UNION ALL 
       SELECT k.id FROM entities k 
       JOIN Xrelationships kc on kc.entityId = k.entityId 
       JOIN GetMembershipInfo m on m.entityId = kc.ChildID 
      ) 

non riesco a trovare una soluzione facile per back- rintracciare quei gruppi che ho già registrato.

Stavo pensando di utilizzare un parametro varchar aggiuntivo nel CTE per registrare un elenco di tutti i gruppi che ho visitato, ma l'uso di varchar è troppo semplice, non è vero?

C'è un modo migliore?

Answer 1

È necessario accumulare una stringa sentinella all'interno della ricorsione. Nel seguente esempio ho un rapporto circolare da A, B, C, D, e quindi ad A, e evito un ciclo con la stringa sentinella:

DECLARE @MyTable TABLE(Parent CHAR(1), Child CHAR(1)); 

INSERT @MyTable VALUES('A', 'B'); 
INSERT @MyTable VALUES('B', 'C'); 
INSERT @MyTable VALUES('C', 'D'); 
INSERT @MyTable VALUES('D', 'A'); 

; WITH CTE (Parent, Child, Sentinel) AS (
    SELECT Parent, Child, Sentinel = CAST(Parent AS VARCHAR(MAX)) 
    FROM @MyTable 
    WHERE Parent = 'A' 
    UNION ALL 
    SELECT CTE.Child, t.Child, Sentinel + '|' + CTE.Child 
    FROM CTE 
    JOIN @MyTable t ON t.Parent = CTE.Child 
    WHERE CHARINDEX(CTE.Child,Sentinel)=0 
) 
SELECT * FROM CTE; 

risultati:

Parent Child Sentinel 
------ ----- -------- 
A  B  A 
B  C  A|B 
C  D  A|B|C 
D  A  A|B|C|D 

Answer 2

Invece di una stringa sentinella, usa una variabile tabella sentinella. La funzione acquisirà un riferimento circolare indipendentemente dal numero di hop del cerchio, nessun problema con la lunghezza massima di nvarchar (max), facilmente modificabile per diversi tipi di dati o persino tasti multipart, ed è possibile assegnare la funzione a un vincolo di controllo.

CREATE FUNCTION [dbo].[AccountsCircular] (@AccountID UNIQUEIDENTIFIER) 
RETURNS BIT 
AS 
BEGIN 
    DECLARE @NextAccountID UNIQUEIDENTIFIER = NULL; 
    DECLARE @Sentinel TABLE 
    (
     ID UNIQUEIDENTIFIER 
    ) 
    INSERT INTO  @Sentinel 
       ([ID]) 
    VALUES   (@AccountID) 
    SET @NextAccountID = @AccountID; 

    WHILE @NextAccountID IS NOT NULL 
    BEGIN 
     SELECT @NextAccountID = [ParentAccountID] 
     FROM [dbo].[Accounts] 
     WHERE [AccountID] = @NextAccountID; 
     IF EXISTS(SELECT 1 FROM @Sentinel WHERE ID = @NextAccountID) 
      RETURN 1; 
     INSERT INTO @Sentinel 
       ([ID]) 
     VALUES  (@NextAccountID) 
    END 
    RETURN 0; 
END