T-SQL Programming Part 2 - Building a T-SQL Loop
November 5, 2003
This is the second article in my T-SQL programming series. This article will discuss building a program loop using T-SQL. In addition to talking about building a loop, I will also discuss ways of controlling the loop processing, and different methods to break out of a loop.
A programming loop is a chunk of code that is executed over and over again. In the loop some logic is executed repeatedly in an iterative fashion until some condition is met that allows the code to break out of the loop. One example of where you might use a loop would be to process through a set of records one record at a time. Another example might be where you need to generate some test data and a loop would allow you to insert a record into your test data table with slightly different column values, each time the loop is executed. In this article I will discuss the WHILE, BREAK, CONTINUE, and GOTO statements.
In T-SQL the WHILE statement is the most commonly used way to execute a loop. Here is the basic syntax for a WHILE loop:
WHILE <Boolean expression> <code block>
Where a <Boolean expression> is any expression that equates to a true or false answer, and the <code block> is the desire code to be executed while the <Boolean expression> is true. Let's go through a real simple example.
In this example I will increment a counter from 1 to 10 and display the counter each time through the WHILE loop.
declare @counter int set @counter = 0 while @counter < 10 begin set @counter = @counter + 1 print 'The counter is ' + cast(@counter as char) end
Here the code executes the WHILE statement as long as the @counter integer variable is less than 10, this is the Boolean expression of the WHILE loop. The @counter variable starts out at zero, and each time through the WHILE loop it is incremented by 1. The PRINT statement displays the value in the @counter variable each time through the WHILE loop. The output from this sample looks like this:
The counter is 1 The counter is 2 The counter is 3 The counter is 4 The counter is 5 The counter is 6 The counter is 7 The counter is 8 The counter is 9 The counter is 10
As you can see, once the @counter variable reaches 10 the Boolean expression that is controlling the WHILE loop is no longer true, so the code within the while loop is no longer executed.
Not only can you have a single while loop, but you can have WHILE loops inside WHILE loops. Or commonly know as nesting of WHILE loops. There are lots of different uses where nesting is valuable. I commonly use nesting of WHILE loops to generate test data. My next example will use the WHILE loop to generate test records for a PART table. A given PART record is uniquely identified by a Part_Id, and a Category_Id. For each Part_Id there are three different Category_Id's. Here is my example that generates 6 unique records for my PART table using a nested WHILE loop.
declare @Part_Id int declare @Category_Id int declare @Desc varchar(50) create table PART (Part_Id int, Category_Id int, Description varchar(50)) set @Part_Id = 0 set @Category_Id = 0 while @Part_Id < 2 begin set @Part_Id = @Part_Id + 1 while @Category_Id < 3 begin set @Category_Id = @Category_Id + 1 set @Desc = 'Part_Id is ' + cast(@Part_Id as char(1)) + ' Category_Id ' + cast(@Category_Id as char(1)) insert into PART values(@Part_Id, @Category_Id, @Desc ) end set @Category_Id = 0 end select * from PART drop table PART
Here is the output from the SELECT statement at the bottom of this nested WHILE loop example.
Part_Id Category_Id Description ----------- ----------- ----------------------------------------- 1 1 Part_Id is 1 Category_Id 1 1 2 Part_Id is 1 Category_Id 2 1 3 Part_Id is 1 Category_Id 3 2 1 Part_Id is 2 Category_Id 1 2 2 Part_Id is 2 Category_Id 2 2 3 Part_Id is 2 Category_Id 3
As you can see, by using a nested WHILE loop each combination of Part_Id and Category_Id is unique. The code within the first WHILE loop controlled the incrementing of the Part_Id, where as the second WHILE loop set the Category_Id to a different value each time through the loop. The code within the first while loop was executed only twice, but the code inside the second WHILE loop was executed 6 times. Thus giving me 6 sample PART records.