it-swarm-ko.tech

커서를 사용하지 않고 SQL에서 테이블 변수를 순환시키는 방법이 있습니까?

다음과 같은 간단한 테이블 변수가 있다고 가정 해 보겠습니다.

declare @databases table
(
    DatabaseID    int,
    Name        varchar(15),   
    Server      varchar(15)
)
-- insert a bunch rows into @databases

행을 반복 할 때 커서를 선언하고 사용하는 유일한 방법은 무엇입니까? 다른 방법이 있습니까?

220
Ray Vega

무엇보다 먼저 각 행을 반복 할 필요가 있다는 확신을 가져야합니다. 집합 기반 연산은 생각할 수있는 모든 경우에 더 빨리 수행되며 일반적으로 더 간단한 코드를 사용합니다.

데이터에 따라 아래와 같이 select 문을 사용하여 루프 할 수 있습니다.

Declare @Id int

While (Select Count(*) From ATable Where Processed = 0) > 0
Begin
    Select Top 1 @Id = Id From ATable Where Processed = 0

    --Do some processing here

    Update ATable Set Processed = 1 Where Id = @Id 

End

또 다른 대안은 임시 테이블을 사용하는 것입니다.

Select *
Into   #Temp
From   ATable

Declare @Id int

While (Select Count(*) From #Temp) > 0
Begin

    Select Top 1 @Id = Id From #Temp

    --Do some processing here

    Delete #Temp Where Id = @Id

End

선택할 수있는 옵션은 실제로 데이터의 구조와 볼륨에 따라 다릅니다.

참고 : SQL Server를 사용하는 경우 다음을 사용하는 것이 더 나을 것입니다.

WHILE EXISTS(SELECT * FROM #Temp)

COUNT을 사용하면 테이블의 모든 단일 행을 터치해야합니다. EXISTS은 첫 번째 행을 만지면됩니다 (아래 Josef의 대답 참조).

331
Martynnw

SQL Server (2008 이상)를 사용하는 경우 다음과 같은 예제가 있습니다.

While (Select Count(*) From #Temp) > 0

더 나은 서비스를 제공 할 수 있을까요?

While EXISTS(SELECT * From #Temp)

백작은 테이블의 모든 단일 행을 터치해야하며 EXISTS은 첫 번째 행을 터치하면됩니다.

124
Josef

이것이 내가하는 일이다.

declare @RowNum int, @CustId nchar(5), @Name1 nchar(25)

select @CustId=MAX(USERID) FROM UserIDs     --start with the highest ID
Select @RowNum = Count(*) From UserIDs      --get total number of records
WHILE @RowNum > 0                          --loop until no more records
BEGIN   
    select @Name1 = username1 from UserIDs where USERID= @CustID    --get other info from that row
    print cast(@RowNum as char(12)) + ' ' + @CustId + ' ' + @Name1  --do whatever

    select top 1 @CustId=USERID from UserIDs where USERID < @CustID order by USERID desc--get the next one
    set @RowNum = @RowNum - 1                               --decrease count
END

커서 없음, 임시 테이블 없음, 추가 열 없음. 대부분의 기본 키와 마찬가지로 USERID 열은 고유 한 정수 여야합니다.

36
Trevor

이런 임시 테이블을 정의하십시오 -

declare @databases table
(
    RowID int not null identity(1,1) primary key,
    DatabaseID    int,
    Name        varchar(15),   
    Server      varchar(15)
)

-- insert a bunch rows into @databases

그런 다음이 작업을 수행하십시오.

declare @i int
select @i = min(RowID) from @databases
declare @max int
select @max = max(RowID) from @databases

while @i <= @max begin
    select DatabaseID, Name, Server from @database where RowID = @i --do some stuff
    set @i = @i + 1
end
20
Seibar

여기 내가 어떻게 할 것 인가 :

Select Identity(int, 1,1) AS PK, DatabaseID
Into   #T
From   @databases

Declare @maxPK int;Select @maxPK = MAX(PK) From #T
Declare @pk int;Set @pk = 1

While @pk <= @maxPK
Begin

    -- Get one record
    Select DatabaseID, Name, Server
    From @databases
    Where DatabaseID = (Select DatabaseID From #T Where PK = @pk)

    --Do some processing here
    -- 

    Select @pk = @pk + 1
End

[편집] 처음으로 질문을 읽을 때 Word "변수"를 건너 뛰었 기 때문에 여기에 업데이트 된 응답이 있습니다 ...


declare @databases table
(
    PK            int IDENTITY(1,1), 
    DatabaseID    int,
    Name        varchar(15),   
    Server      varchar(15)
)
-- insert a bunch rows into @databases
--/*
INSERT INTO @databases (DatabaseID, Name, Server) SELECT 1,'MainDB', 'MyServer'
INSERT INTO @databases (DatabaseID, Name, Server) SELECT 1,'MyDB',   'MyServer2'
--*/

Declare @maxPK int;Select @maxPK = MAX(PK) From @databases
Declare @pk int;Set @pk = 1

While @pk <= @maxPK
Begin

    /* Get one record (you can read the values into some variables) */
    Select DatabaseID, Name, Server
    From @databases
    Where PK = @pk

    /* Do some processing here */
    /* ... */ 

    Select @pk = @pk + 1
End
16
leoinfo

FAST_FORWARD 커서를 만드는 행 단위로 이동하는 것보다 선택의 여지가없는 경우. while 루프를 구축하는 것만큼이나 빠르며 장기간에 걸쳐 유지하기가 훨씬 쉬울 것입니다.

FAST_FORWARD 성능 최적화가 사용되는 FORWARD_ONLY, READ_ONLY 커서를 지정합니다. SCROLL 또는 FOR_UPDATE도 지정되면 FAST_FORWARD를 지정할 수 없습니다.

9
Wes Brown

스키마를 변경하거나 임시 테이블을 사용하지 않고도 다른 접근 방법 :

DECLARE @rowCount int = 0
  ,@currentRow int = 1
  ,@databaseID int
  ,@name varchar(15)
  ,@server varchar(15);

SELECT @rowCount = COUNT(*)
FROM @databases;

WHILE (@currentRow <= @rowCount)
BEGIN
  SELECT TOP 1
     @databaseID = rt.[DatabaseID]
    ,@name = rt.[Name]
    ,@server = rt.[Server]
  FROM (
    SELECT ROW_NUMBER() OVER (
        ORDER BY t.[DatabaseID], t.[Name], t.[Server]
       ) AS [RowNumber]
      ,t.[DatabaseID]
      ,t.[Name]
      ,t.[Server]
    FROM @databases t
  ) rt
  WHERE rt.[RowNumber] = @currentRow;

  EXEC [your_stored_procedure] @databaseID, @name, @server;

  SET @currentRow = @currentRow + 1;
END
4
SReiderB

테이블에 정수 ID이 있으면 추가 테이블을 만들 필요없이 가볍습니다.

Declare @id int = 0, @anything nvarchar(max)
WHILE(1=1) BEGIN
  Select Top 1 @anything=[Anything],@[email protected]+1 FROM Table WHERE ID>@id
  if(@@ROWCOUNT=0) break;

  --Process @anything

END
3
Control Freak

While 루프를 사용할 수 있습니다.

While (Select Count(*) From #TempTable) > 0
Begin
    Insert Into @Databases...

    Delete From #TempTable Where x = x
End
3
GateKiller
-- [PO_RollBackOnReject]  'FININV10532'
alter procedure PO_RollBackOnReject
@CaseID nvarchar(100)

AS
Begin
SELECT  *
INTO    #tmpTable
FROM   PO_InvoiceItems where CaseID = @CaseID

Declare @Id int
Declare @PO_No int
Declare @Current_Balance Money


While (Select ROW_NUMBER() OVER(ORDER BY PO_LineNo DESC) From #tmpTable) > 0
Begin
        Select Top 1 @Id = PO_LineNo, @Current_Balance = Current_Balance,
        @PO_No = PO_No
        From #Temp
        update PO_Details
        Set  Current_Balance = Current_Balance + @Current_Balance,
            Previous_App_Amount= Previous_App_Amount + @Current_Balance,
            Is_Processed = 0
        Where PO_LineNumber = @Id
        AND PO_No = @PO_No
        update PO_InvoiceItems
        Set IsVisible = 0,
        Is_Processed= 0
        ,Is_InProgress = 0 , 
        Is_Active = 0
        Where PO_LineNo = @Id
        AND PO_No = @PO_No
End
End
3
Syed Umar Ahmed

나는 정말 당신이 두려운 cursor을 사용하는 것에 의지 할 필요가있는 요점을 보지 못합니다. 그러나 SQL Server 버전 2005/2008을 사용하는 경우 다른 옵션이 있습니다.
사용 재귀

declare @databases table
(
    DatabaseID    int,
    Name        varchar(15),   
    Server      varchar(15)
)

--; Insert records into @databases...

--; Recurse through @databases
;with DBs as (
    select * from @databases where DatabaseID = 1
    union all
    select A.* from @databases A 
        inner join DBs B on A.DatabaseID = B.DatabaseID + 1
)
select * from DBs
2
Sung M. Kim

이 SQL Server 2012 버전에서 작동합니다.

declare @Rowcount int 
select @Rowcount=count(*) from AddressTable;

while( @Rowcount>0)
  begin 
 select @[email protected];
 SELECT * FROM AddressTable order by AddressId desc OFFSET @Rowcount ROWS FETCH NEXT 1 ROWS ONLY;
end 
2
OrganicCoder

세트 기반 솔루션을 제공 할 것입니다.

insert  @databases (DatabaseID, Name, Server)
select DatabaseID, Name, Server 
From ... (Use whatever query you would have used in the loop or cursor)

이것은 어떤 루핑 테크닉보다 훨씬 빠르며 작성하고 유지하기가 더 쉽습니다.

2
HLGEM

이 방법은 하나의 변수 만 필요하며 @databases에서 어떤 행도 삭제하지 않습니다. 여기에 많은 답변이 있다는 것을 알고 있지만, 다음 번 ID를 얻기 위해 MIN을 사용하는 사람은 없습니다.

DECLARE @databases TABLE
(
    DatabaseID    int,
    Name        varchar(15),   
    Server      varchar(15)
)

-- insert a bunch rows into @databases

DECLARE @CurrID INT

SELECT @CurrID = MIN(DatabaseID)
FROM @databases

WHILE @CurrID IS NOT NULL
BEGIN

    -- Do stuff for @CurrID

    SELECT @CurrID = MIN(DatabaseID)
    FROM @databases
    WHERE DatabaseID > @CurrID

END
1
Sean

이를 위해 커서를 사용할 수 있습니다 :

함수 만들기 [dbo] .f_teste_loop은 begin으로 @tabela 테이블 (cod int, nome varchar (10))을 반환합니다.

insert into @tabela values (1, 'verde');
insert into @tabela values (2, 'amarelo');
insert into @tabela values (3, 'azul');
insert into @tabela values (4, 'branco');

return;

종료

프로 시저 [dbo]를 만듭니다. [sp_teste_loop] as begin

DECLARE @cod int, @nome varchar(10);

DECLARE curLoop CURSOR STATIC LOCAL 
FOR
SELECT  
    cod
   ,nome
FROM 
    dbo.f_teste_loop();

OPEN curLoop;

FETCH NEXT FROM curLoop
           INTO @cod, @nome;

WHILE (@@FETCH_STATUS = 0)
BEGIN
    PRINT @nome;

    FETCH NEXT FROM curLoop
           INTO @cod, @nome;
END

CLOSE curLoop;
DEALLOCATE curLoop;

종료

1
Alexandre Pezzutto

무한 루프, BREAK 문 및 @@ROWCOUNT 함수를 사용하는 내 솔루션은 다음과 같습니다. 커서 나 임시 테이블이 필요하지 않으며 @databases 테이블의 다음 행을 얻기 위해 하나의 쿼리 만 작성하면됩니다.

declare @databases table
(
    DatabaseID    int,
    [Name]        varchar(15),   
    [Server]      varchar(15)
);


-- Populate the [@databases] table with test data.
insert into @databases (DatabaseID, [Name], [Server])
select X.DatabaseID, X.[Name], X.[Server]
from (values 
    (1, 'Roger', 'ServerA'),
    (5, 'Suzy', 'ServerB'),
    (8675309, 'Jenny', 'TommyTutone')
) X (DatabaseID, [Name], [Server])


-- Create an infinite loop & ensure that a break condition is reached in the loop code.
declare @databaseId int;

while (1=1)
begin
    -- Get the next database ID.
    select top(1) @databaseId = DatabaseId 
    from @databases 
    where DatabaseId > isnull(@databaseId, 0);

    -- If no rows were found by the preceding SQL query, you're done; exit the WHILE loop.
    if (@@ROWCOUNT = 0) break;

    -- Otherwise, do whatever you need to do with the current [@databases] table row here.
    print 'Processing @databaseId #' + cast(@databaseId as varchar(50));
end
1
Mass Dot Net

나는 이전에 set-based 연산이 일반적으로 더 잘 수행된다는 점에 동의하지만 행에 대해 반복 할 필요가 있다면 여기에 접근 할 방법이있다.

  1. 테이블 변수에 새 필드 추가 (데이터 유형 비트, 기본값 0)
  2. 데이터 삽입
  3. FUsed = 0 인 Top 1 Row를 선택하십시오 (주 : fUsed는 1 단계의 필드 이름입니다)
  4. 수행해야 할 처리를 수행하십시오.
  5. 레코드에 fUsed = 1을 설정하여 테이블 변수의 레코드를 업데이트하십시오.
  6. 테이블에서 다음 사용되지 않은 레코드를 선택하고 프로세스를 반복하십시오.

    DECLARE @databases TABLE  
    (  
        DatabaseID  int,  
        Name        varchar(15),     
        Server      varchar(15),   
        fUsed       BIT DEFAULT 0  
    ) 
    
    -- insert a bunch rows into @databases
    
    DECLARE @DBID INT
    
    SELECT TOP 1 @DBID = DatabaseID from @databases where fUsed = 0 
    
    WHILE @@ROWCOUNT <> 0 and @DBID IS NOT NULL  
    BEGIN  
        -- Perform your processing here  
    
        --Update the record to "used" 
    
        UPDATE @databases SET fUsed = 1 WHERE DatabaseID = @DBID  
    
        --Get the next record  
        SELECT TOP 1 @DBID = DatabaseID from @databases where fUsed = 0   
    END
    
1
Tim Lentine

나는 당신이 당신의 테이블을 다음과 같이 정렬 할 수있는 유일한 ID를 가지고 있다면 Offset Fetch를 선호한다.

DECLARE @TableVariable (ID int, Name varchar(50));
DECLARE @RecordCount int;
SELECT @RecordCount = COUNT(*) FROM @TableVariable;

WHILE @RecordCount > 0
BEGIN
SELECT ID, Name FROM @TableVariable ORDER BY ID OFFSET @RecordCount - 1 FETCH NEXT 1 ROW;
SET @RecordCount = @RecordCount - 1;
END

이 방법으로 테이블에 필드를 추가하거나 창 함수를 사용할 필요가 없습니다.

1
Yves A Martin

1 단계 : 아래 select 문은 각 레코드에 고유 한 행 번호가있는 임시 테이블을 만듭니다.

select eno,ename,eaddress,mobno int,row_number() over(order by eno desc) as rno into #tmp_sri from emp 

2 단계 : 필수 변수 선언

DECLARE @ROWNUMBER INT
DECLARE @ename varchar(100)

3 단계 : 임시 테이블에서 총 행 수 가져 오기

SELECT @ROWNUMBER = COUNT(*) FROM #tmp_sri
declare @rno int

Step4 : temp에서 고유 한 행 번호를 기반으로 루프 임시 테이블 생성

while @rownumber>0
begin
  set @[email protected]
  select @ename=ename from #tmp_sri where [email protected]  **// You can take columns data from here as many as you want**
  set @[email protected]
  print @ename **// instead of printing, you can write insert, update, delete statements**
end
0
Srinivas Maale

이것은 2008 R2를 사용하고있는 코드입니다. 이 코드는 키 필드 (SSNO & EMPR_NO) n 모든 이야기에 대한 인덱스를 작성하는 데 사용하고 있습니다.

if object_ID('tempdb..#a')is not NULL drop table #a

select 'IF EXISTS (SELECT name FROM sysindexes WHERE name ='+CHAR(39)+''+'IDX_'+COLUMN_NAME+'_'+SUBSTRING(table_name,5,len(table_name)-3)+char(39)+')' 
+' begin DROP INDEX [IDX_'+COLUMN_NAME+'_'+SUBSTRING(table_name,5,len(table_name)-3)+'] ON '+table_schema+'.'+table_name+' END Create index IDX_'+COLUMN_NAME+'_'+SUBSTRING(table_name,5,len(table_name)-3)+ ' on '+ table_schema+'.'+table_name+' ('+COLUMN_NAME+') '   'Field'
,ROW_NUMBER() over (order by table_NAMe) as  'ROWNMBR'
into #a
from INFORMATION_SCHEMA.COLUMNS
where (COLUMN_NAME like '%_SSNO_%' or COLUMN_NAME like'%_EMPR_NO_')
    and TABLE_SCHEMA='dbo'

declare @loopcntr int
declare @ROW int
declare @String nvarchar(1000)
set @loopcntr=(select count(*)  from #a)
set @ROW=1  

while (@ROW <= @loopcntr)
    begin
        select top 1 @String=a.Field 
        from #A a
        where a.ROWNMBR = @ROW
        execute sp_executesql @String
        set @ROW = @ROW + 1
    end 
0
howmnsk

@pk = @pk + 1을 선택하는 것이 좋습니다 : SET @pk + = @pk. 참조하는 테이블이 값을 할당하는 것이 아닌 경우 SELECT를 사용하지 마십시오.

0
Bob Alley