È possibile che una stored procedure venga chiamata in modo ricorsivo in SQL Server?

Question

Ecco quello che ho come VBScript sottoprogrammi:

sub buildChildAdminStringHierarchical(byval pAdminID, byref adminString) 
    set rsx = conn.execute ("select admin_id from administrator_owners where admin_id not in (" & adminString & ") and owner_id = " & pAdminID) 

    do while not rsx.eof 
     adminString = adminString & "," & rsx(0) 
     call buildChildAdminStringHierarchical(rsx(0),adminString) 
     rsx.movenext 
    loop 
end sub 

Esiste un modo per trasformare questo in una stored procedure dal momento che è ricevuto la chiamata ricorsiva nella subroutine?

Ecco che cosa ho provato ...

CREATE PROCEDURE usp_build_child_admin_string_hierarchically 
    @ID AS INT, 
    @ADMIN_STRING AS VARCHAR(8000), 
    @ID_STRING AS VARCHAR(8000) OUTPUT 
AS 
BEGIN 
    -- SET NOCOUNT ON added to prevent extra result sets from 
    -- interfering with SELECT statements. 
    SET NOCOUNT ON; 

    DECLARE @index int; 
    DECLARE @length int; 
    DECLARE @admin_id int; 
    DECLARE @new_string varchar(8000); 

    SET @index = 1; 
    SET @length = 0; 
    SET @new_string = @ADMIN_STRING; 

    CREATE TABLE #Temp (ID int) 

    WHILE @index <= LEN(@new_string) 
    BEGIN 
     IF CHARINDEX(',', @new_string, @index) = 0 
      SELECT @length = (LEN(@new_string) + 1) - @index; 
     ELSE 
      SELECT @length = (CHARINDEX(',', @new_string, @index) - @index); 
     SELECT @admin_id = CONVERT(INT,SUBSTRING(@new_string, @index, @length)); 
     SET @index = @index + @length + 1; 
     INSERT INTO #temp VALUES(@admin_id); 
    END 

    DECLARE TableCursor CURSOR FOR 
     SELECT Admin_ID FROM Administrator_Owners WHERE Admin_ID NOT IN (SELECT ID FROM #temp) AND Owner_ID = @ID; 

    OPEN TableCursor; 
    FETCH NEXT FROM TableCursor INTO @admin_id; 

    WHILE @@FETCH_STATUS = 0 
    BEGIN 
     IF LEN(@ID_STRING) > 0 
     SET @ID_STRING = @ID_STRING + ',' + CONVERT(VARCHAR, @admin_id); 
     ELSE 
     SET @ID_STRING = CONVERT(VARCHAR, @admin_id); 

     EXEC usp_build_child_admin_string_hierarchically @admin_id, @ID_STRING, @ID_STRING; 

     FETCH NEXT FROM TableCursor INTO @admin_id; 
    END 

    CLOSE TableCursor; 
    DEALLOCATE TableCursor; 

    DROP TABLE #temp; 
END 
GO 

ma ottengo il seguente errore quando che stored procedure viene chiamata ... Un cursore con lo stesso nome 'TableCursor' esiste già.

Answer 1

Il problema è che mentre il cursore non è globale, è un cursore di sessione. Dato che stai facendo la ricorsione, anche se ogni iterazione sta creando un cursore in un nuovo ambito proc, vengono tutti creati nello stesso PID (connessione) allo stesso tempo, quindi la collisione.

È necessario generare nomi di cursore univoci in ogni iterazione della procedura in base a determinati criteri che non verranno riprodotti durante la ricorsione.

Oppure, preferibilmente, trovare un modo per eseguire ciò che è necessario utilizzando la logica impostata e gestire qualsiasi ricorsione necessaria utilizzando un CTE ricorsivo.

Answer 2

È possibile, ma di solito non è una buona idea. SQL è realizzato per operazioni basate su set. Inoltre, in MS SQL Server almeno, la ricorsione è limitata al numero di chiamate ricorsive che può effettuare. Puoi solo annidare fino a 32 livelli in profondità.

Il problema nel tuo caso è che il CURSORE dura attraverso ogni chiamata, quindi si finisce per crearlo più di una volta.

Answer 3

È possibile specificare un cursore LOCAL, in questo modo:

DECLARE TableCursor CURSOR LOCAL FOR 
SELECT ... 

Almeno in SQL Server 2008 R2 (la mia macchina), questo consente di chiamare in modo ricorsivo lo sproc senza incorrere in "Cursore esiste già" errori .