T-SQL: Bucle a través de una matriz de valores conocidos

Lo que hago en este escenario es crear una variable de tabla para contener los Ids.

  Declare @Ids Table (id integer primary Key not null)
  Insert @Ids(id) values (4),(7),(12),(22),(19)

} (o llame a otra función de valor de tabla para generar esta tabla)

Luego bucle basado en las filas de esta tabla

  Declare @Id Integer
  While exists (Select * From @Ids)
    Begin
      Select @Id = Min(id) from @Ids
      exec p_MyInnerProcedure @Id 
      Delete from @Ids Where id = @Id
    End

O...

  Declare @Id Integer = 0 -- assuming all Ids are > 0
  While exists (Select * From @Ids
                where id > @Id)
    Begin
      Select @Id = Min(id) 
      from @Ids Where id > @Id
      exec p_MyInnerProcedure @Id 
    End

Cualquiera de los enfoques anteriores es mucho más rápido que un cursor (declarado contra Tablas de usuarios regulares). Las variables con valor de tabla tienen una mala reputación porque cuando se usan incorrectamente, (para tablas muy anchas con gran número de filas) no tienen rendimiento. Pero si los está usando solo para mantener un valor de clave o un entero de 4 bytes, con un índice (como en este caso) son extremadamente rápidos.

Use una variable de cursor estática y una función de división :

declare @comma_delimited_list varchar(4000)
set @comma_delimited_list = '4,7,12,22,19'

declare @cursor cursor
set @cursor = cursor static for 
  select convert(int, Value) as Id from dbo.Split(@comma_delimited_list) a

declare @id int
open @cursor
while 1=1 begin
  fetch next from @cursor into @id
  if @@fetch_status <> 0 break
  ....do something....
end
-- not strictly necessary w/ cursor variables since they will go out of scope like a normal var
close @cursor
deallocate @cursor

Los cursores tienen una mala reputación ya que las opciones predeterminadas cuando se declaran contra tablas de usuarios pueden generar una gran sobrecarga.

Pero en este caso la sobrecarga es bastante mínima, menos que cualquier otro método aquí. STATIC le dice a SQL Server que materialice los resultados en tempdb y luego itere sobre eso. Para listas pequeñas como esta, es la solución óptima.

Normalmente utilizo el siguiente enfoque

DECLARE @calls TABLE (
    id INT IDENTITY(1,1)
    ,parameter INT
    )

INSERT INTO @calls
select parameter from some_table where some_condition -- here you populate your parameters

declare @i int
declare @n int
declare @myId int
select @i = min(id), @n = max(id) from @calls
while @i <= @n
begin
    select 
        @myId = parameter
    from 
        @calls
    where id = @i

        EXECUTE p_MyInnerProcedure @myId
    set @i = @i+1
end

CREATE TABLE #ListOfIDs (IDValue INT)

DECLARE @IDs VARCHAR(50), @ID VARCHAR(5)
SET @IDs = @OriginalListOfIDs + ','

WHILE LEN(@IDs) > 1
BEGIN
SET @ID = SUBSTRING(@IDs, 0, CHARINDEX(',', @IDs));
INSERT INTO #ListOfIDs (IDValue) VALUES(@ID);
SET @IDs = REPLACE(',' + @IDs, ',' + @ID + ',', '')
END

SELECT * 
FROM #ListOfIDs

Puede intentar lo siguiente:

declare @list varchar(MAX), @i int
select @i=0, @list ='4,7,12,22,19,'

while( @i < LEN(@list))
begin
    declare @item varchar(MAX)
    SELECT  @item = SUBSTRING(@list,  @i,CHARINDEX(',',@list,@i)-@i)
    select @item

     --do your stuff here with @item 
     exec p_MyInnerProcedure @item 

    set @i = CHARINDEX(',',@list,@i)+1
    if(@i = 0) set @i = LEN(@list) 
end