Week 7

Database Programming: Cursors,

Triggers and Stored Procedures
 Cursors
 CURrent Set Of Rows: a set of records
returned from a query
 Represent the entire set of records
 Support navigation and iteration through
records, one at a time
 Record based solution vs. set-based
solution
 Forward-only and updatable
 Make certain columns of a cursor updatable
and the rest being read-only
 Creating a cursor
 Declare a cursor-type variable
– Special type of non-scalar object
– Variable name isn't prefixed with an at symbol (@)
– The cursor variable can be declared and defined on the same line
with the SELECT statement used to populate the cursor

DECLARE curProduct INSENSITIVE CURSOR FOR

SELECT ProductID, Name FROM Product
 To create a cursor that allows updates only to and from the
Name column of the Product table, declare the cursor like
this:
DECLARE curProduct CURSOR FOR
SELECT ProductID, Name FROM Product FOR UPDATE OF Name
 Loading a cursor
 The cursor isn't actually populated until it is opened.
 Executing the OPEN command loads the cursor structure and data into
memory:

OPEN curProduct

 At this point, the record pointer is positioned before the first row. The
FETCH NEXT command navigates the pointer to the next record and
returns a comma-delimited list of column values. In this case, the
pointer is moved to the first row. Individual variables can be used to
capture the values of the current row's column values:

DECLARE @ProdID Int

DECLARE @ProdName VarChar(100)
FETCH NEXT FROM curProduct INTO @ProdID, @ProdName
 Capturing column value from cursor
into variables
 After FETCH NEXT is executed, one of two things will
happen: the record pointer will either be positioned on a
valid record or it will navigate beyond the last row.
 The state of the pointer can be determined using the global
variable @@Fetch_Status.
 On a valid row, it returns 0, otherwise it returns –1 or –2.
 It returns –1 if there is no next row to fetch. If a –2 is
returned it means that the next row was deleted in the
underlying table when using an updatable cursor.
 Using this variable, create a simple loop, navigating to the
next record as long as @@Fetch_Status is equal to 0:

WHILE @@Fetch_Status = 0 BEGIN PRINT @ProdName

FETCH NEXT FROM curProduct INTO @ProdID,
@ProdName END
 Close the cursor
 Closing the cursor and free up the memory:
CLOSE curProduct
DEALLOCATE curProduct
 Complete Codes
DECLARE curProduct INSENSITIVE CURSOR FOR
SELECT ProductID, Name FROM Product

DECLARE @ProdID Int

DECLARE @ProdName VarChar(100)

OPEN curProduct
FETCH NEXT FROM curProduct INTO @ProdID, @ProdName
WHILE @@Fetch_Status = 0
BEGIN
PRINT @ProdName
FETCH NEXT FROM curProduct INTO @ProdID, @ProdName
END
CLOSE curProduct
DEALLOCATE curProduct
 Use of Cursors
 Use conditional statements to decide
whether to perform related operations, such
as inserting or deleting records.
 Use cursors to conditionally call different
stored procedures under different
conditions, to perform practically any
combination of operations.
 User-Defined Functions
 Scalar functions
 Multi-statement table-valued functions
 Inline table-valued functions
 Scalar functions
 A scalar function accepts any number of parameters and returns one value.
 Input parameters are declared within parentheses followed by the return value
declaration.
 All statements must be enclosed in a BEGIN. . . END block.
 Calculate the age by getting the number of days between the birth date and
today's date. Because my function can't call the nondeterministic GETDATE()
function, this value must be passed into the function using the @Today
parameter.
 The number of days is divided by the average number of days in a year to
determine the result:

CREATE FUNCTION fnGetAge (@BirthDate DateTime, @Today DateTime)

RETURNS Int
AS
BEGIN
RETURN DateDiff(day, @BirthDate, @Today) / 365.25
END

 User-defined scalar functions are always called using multi-part names,

prefixed at least with the owner or schema name:

SELECT dbo.fnGetAge('1/4/1962', GetDate())

 More example of User-defined Function
CREATE FUNCTION fnGetLastName
(@FullName VarChar(100))
RETURNS VarChar(100)
AS
BEGIN
DECLARE @CommaPosition Int
DECLARE @LastName VarChar(100)
SET @CommaPosition = CHARINDEX(‘,’)
SET @LastName = SUBSTRING(@FullName, 1,
@CommaPosition - 1)
RETURN @LastName
END
 Multi-statement Function
CREATE FUNCTION fnProductListBySubCategory (@SubCategoryID
Int)
RETURNS @ProdList Table ( ProductID Int , Name nVarChar(50) ,
ListPrice Money )
AS BEGIN
IF @SubCategoryID IS NULL
BEGIN
INSERT INTO @ProdList (ProductID, Name, ListPrice)
SELECT ProductID, Name, ListPrice FROM Product
END
ELSE
BEGIN
INSERT INTO @ProdList (ProductID, Name, ListPrice)
SELECT ProductID, Name, ListPrice FROM Product
WHERE ProductSubCategoryID = @SubCategoryID
END
RETURN
END
 Stored Procedures
 stored procedures can be used to do the
following:
– Implement parameterized views
– Return scalar values
– Maintain records
– Process business logic
 Stored Procedures as
Parameterized Views
 SP returns a result set based on a SELECT
statement
 SP is executed, not selected
 Creating a view:
CREATE VIEW vProductCosts AS SELECT
ProductID, ProductSubcategoryID, Name,
ProductNumber, StandardCost FROM Product
 Creating a SP:
CREATE PROCEDURE spProductCosts AS SELECT
ProductID, ProductSubcategoryID, Name,
ProductNumber,
StandardCost FROM Product
 Using Parameters
 A parameter is a special type of variable used to pass
values into an expression.
 Named parameters are used for passing values into and
out of stored procedures and user-defined-functions.
 Parameters are most typically used to input, or pass values
into, a procedure, but can also be used to return values.
 Parameters are declared immediately after the procedure
definition and before the term AS.
 Parameters are declared with a specific data type and are
used as variables in the body of a SQL statement.
Parameterised Stored Procedure
ALTER/Create PROCEDURE spProductCosts
@SubCategoryID Int
AS SELECT ProductID, Name, ProductNumber,
StandardCost FROM Product WHERE
ProductSubCategoryID = @SubCategoryID
 To execute the procedure and pass the parameter
value, append the parameter value to the end of
the EXEC statement, like this:

EXECUTE spProductCosts 1 or
EXECUTE spProductCosts @SubCategory = 1
 SP with Multiple Parameters
CREATE PROCEDURE spProductsByCost
@SubCategoryID Int, @Cost Money
AS
SELECT ProductID, Name, ProductNumber, StandardCost
FROM Product WHERE ProductSubCategoryID =
@SubCategoryID AND StandardCost > @Cost
 Using SQL, the multiple parameters can be passed in a
comma-delimited list in the order they were declared:

EXECUTE spProductsByCost 1, $1000.00 or

EXECUTE spProductsByCost @Cost = $1000.00,
@SubCategoryID = 1
 Use SP with Views
ALTER / Create PROCEDURE spProductCosts
@SubCategoryID Int
AS
SELECT ProductID, Name, ProductNumber,
StandardCost FROM vProductCosts WHERE
ProductSubCategoryID = @SubCategoryID

EXECUTE spProductCosts 1 or
EXECUTE spProductCosts @SubCategory = 1
 Use Parameters to Return Values
 This example shows how to pass the SubCategoryID using
an input parameter and return the record count using an
output parameter:
CREATE PROCEDURE spProductCountBySubCategory
@SubCategoryID Int, @ProdCount Int OUTPUT
AS
SELECT @ProdCount = COUNT(*) FROM Product
WHERE ProductSubCategoryID = @SubCategoryID

 To test a stored procedure with output parameters in the

Management Studio or Query Analyzer environments, it is
necessary to explicitly use these parameters by name.
DECLARE @Out Int

EXECUTE spProductCountBySubCategory
@SubCategoryID = 2, @ProdCount = @Out OUTPUT

SELECT @Out AS ProductCountBySubCategory

ProductCountBySubCategory
-------------------------
184
 An Alternative Method for Return a
Value from SP
CREATE PROCEDURE
spProductCountBySubCategory
@SubCategoryID Int

AS
DECLARE @Out Int
SELECT @Out = Count(*) FROM Product WHERE
ProductSubCategoryID = @SubCategoryID

RETURN @Out
 Use SPs to Manage Records
 Any program code written to perform record
operations should do so using stored
procedures and not ad-hoc SQL
expressions
– Insert, Update, Delete, and Select
 Insert Procedure
 Define parameters for all non-default or auto-populated
columns.
 In the case of the Product table, the ProductID primary key
column will automatically be incremented because it's
defined as an identity column; the rowguid and ModifiedDate
columns have default values assigned in the table definition.
 The MakeFlag and FinishedGoodsFlag columns also have
default values assigned in the table definition, but it may be
appropriate to set these values differently for some records.
 For this reason, these parameters are set to the same
default values in the procedure.
 Several columns are nullable and the corresponding
parameters are set to a default value of null.
 If a parameter with a default assignment isn't provided when
the procedure is executed, the default value is used.
Otherwise, all parameters without default values must be
supplied
 Declaring Variables for Insert
Procedure
CREATE PROCEDURE spProduct_Insert
@Name nVarChar(50) , @ProductNumber nVarChar(25) ,
@MakeFlag Bit = 1 , @FinishedGoodsFlag Bit = 1 ,
@Color nVarChar(15) = Null , @SafetyStockLevel SmallInt ,
@ReorderPoint SmallInt ,
@StandardCost Money , @ListPrice Money ,
@Size nVarChar(5) = Null ,
@SizeUnitMeasureCode nChar(3) = Null ,
@WeightUnitMeasureCode nChar(3) = Null ,
@Weight Decimal = Null , @DaysToManufacture Int ,
@ProductLine nChar(2) = Null , @Class nChar(2) = Null ,
@Style nChar(2) = Null , @ProductSubcategoryID SmallInt = Null ,
@ProductModelID Int = Null , @SellStartDate DateTime ,
@SellEndDate DateTime = Null , @DiscontinuedDate DateTime = Null
 Insert Statements
AS
INSERT INTO Product ( Name , ProductNumber ,
MakeFlag , FinishedGoodsFlag , Color ,
SafetyStockLevel , ReorderPoint , StandardCost ,
ListPrice , Size , SizeUnitMeasureCode ,
WeightUnitMeasureCode , Weight ,
DaysToManufacture , ProductLine , Class , Style ,
ProductSubcategoryID , ProductModelID ,
SellStartDate , SellEndDate , DiscontinuedDate )
 Select Statements
SELECT @Name , @ProductNumber ,
@MakeFlag , @FinishedGoodsFlag , @Color ,
@SafetyStockLevel , @ReorderPoint ,
@StandardCost , @ListPrice , @Size ,
@SizeUnitMeasureCode ,
@WeightUnitMeasureCode , @Weight ,
@DaysToManufacture , @ProductLine , @Class ,
@Style , @ProductSubcategoryID ,
@ProductModelID , @SellStartDate ,
@SellEndDate , @DiscontinuedDate
 Execute the SP
EXECUTE spProduct_
Insert
@Name = 'Widget' , @ProductNumber = '987654321' ,
@SafetyStockLevel = 10 , @ReorderPoint = 15 ,
@StandardCost = 23.50 , @ListPrice = 49.95 ,
@DaysToManufacture = 30 , @SellStartDate = '10/1/04'

Or

EXECUTE spProduct_
Insert 'Widget', '987654321', 1, 1, Null, 10, 15, 23.50,
49.95, Null, Null, Null, Null, 30, Null, Null, Null, Null, Null,
'10/1/04'
Update Procedure: Declare all Variables
CREATE PROCEDURE spProduct_Update
@ProductID Int , @Name nVarChar(50) ,
@ProductNumber nVarChar(25) , @MakeFlag Bit = 1 ,
@FinishedGoodsFlag Bit = 1 ,
@Color nVarChar(15) = Null , @SafetyStockLevel SmallInt
, @ReorderPoint SmallInt , @StandardCost Money ,
@ListPrice Money , @Size nVarChar(5) = Null ,
@SizeUnitMeasureCode nChar(3) = Null ,
@WeightUnitMeasureCode nChar(3) = Null ,
@Weight Decimal = Null , @DaysToManufacture Int ,
@ProductLine nChar(2) = Null , @Class nChar(2) = Null ,
@Style nChar(2) = Null , @ProductSubcategoryID SmallInt
= Null , @ProductModelID Int = Null , @SellStartDate
DateTime , @SellEndDate DateTime = Null ,
@DiscontinuedDate DateTime = Null
 Update Statements
AS
UPDATE Product
SET
Name = @Name , ProductNumber = @ProductNumber ,
MakeFlag = @MakeFlag , FinishedGoodsFlag = @FinishedGoodsFlag ,
Color = @Color , SafetyStockLevel = @SafetyStockLevel ,
ReorderPoint = @ReorderPoint , StandardCost = @StandardCost ,
ListPrice = @ListPrice , Size = @Size ,
SizeUnitMeasureCode = @SizeUnitMeasureCode ,
WeightUnitMeasureCode = @WeightUnitMeasureCode ,
Weight = @Weight , DaysToManufacture = @DaysToManufacture ,
ProductLine = @ProductLine , Class = @Class , Style = @Style ,
ProductSubcategoryID = @ProductSubcategoryID ,
ProductModelID = @ProductModelID , SellStartDate = @SellStartDate ,
SellEndDate = @SellEndDate , DiscontinuedDate = @DiscontinuedDate

WHERE ProductID = @ProductID

Exec spProduct_Update 1;
 Delete Procedure
CREATE PROCEDURE spProduct_Delete
@ProductID Int
AS
DELETE FROM Product
WHERE ProductID = @ProductID

Exec spProduct_Delete 2
 Triggers
 DML Triggers:
– A special type of SP, executed automatically
based on occurrence of a database event.
– Data manipulation: insert, update, delete
 DDL triggers: Also on DDL events in 2005
 DML Triggers
 Compare before and after versions of data.
 Roll back invalid modifications.
 Read from other tables, including those in
other databases.
 Modify other tables, including those in other
databases.
 Execute local and remote stored
procedures.
 Creating DML Triggers
 Using system trigger templates
– SELECT * FROM sys.triggers
 AFTER trigger
– Invoked when any data modification takes place but before data
are committed to the database
 Basic Syntax

CREATE TRIGGER trigger_name

ON table_name
AFTER { INSERT | UPDATE | DELETE }
AS
SQL statements
 An example of AFTER Trigger
 This trigger prints a message, stating the
number of rows updated by an UPDATE
statement. You then execute a couple
UPDATE statements to see whether the
trigger works.
 Codes
CREATE TRIGGER tr_au_upd ON authors
AFTER UPDATE
AS
Create View vOldStockLevel AS Select ProdID, Stocklevel from Products
Print ‘Your old stocklevel data are as follows:’
Select * from vOldStockLevel
PRINT ‘TRIGGER OUTPUT: ‘ +CONVERT(VARCHAR(5), @@ROWCOUNT)
+ ‘ rows were updated.’

GO
UPDATE products
SET stock_level = stock_level + 3
WHERE state = ‘UT’
GO

Select ProdID, stock_leve from Products

Your old stocklevel data are as follows:

ProdID Stock_Level
1 2
You new stocklevel data are as follows:
ProdID Stock_Level
1 5

--TRIGGER OUTPUT: 1 rows were updated.

UPDATE authors
SET au_fname = au_fname
WHERE state = ‘CA’
GO
--TRIGGER OUTPUT: 37 rows were updated.
 Limitations of AFTER Triggers
 The following restrictions apply to AFTER
triggers:
 AFTER triggers can be placed only on
tables, not on views.
 An AFTER trigger cannot be placed on more
than one table.
 The text, ntext, and image columns cannot
be referenced in the AFTER trigger logic.
 Displaying Deleted or Inserted
Records within an AFTER Trigger
 Using Inserted table and Deleted table
 Both tables are available to the trigger.
 The changes displayed are not committed
until the trigger completes.
 Codes
--Create a copy of the titles table in the BigPubs2005
database
SELECT *
INTO titles_copy
FROM titles
GO
--add an AFTER trigger to this table for testing purposes
CREATE TRIGGER tc_tr ON titles_copy
FOR INSERT, UPDATE, DELETE
AS
PRINT ‘Inserted:’
SELECT title_id, type, price FROM inserted
PRINT ‘Deleted:’
SELECT title_id, type, price FROM deleted
ROLLBACK TRANSACTION
 Results of Firing the Trigger
UPDATE titles_copy
SET price = $15.05
WHERE type LIKE ‘%cook%’

Inserted:
title_id type price
-------- ------------ ---------------------
TC7777 trad_cook 15.05
TC4203 trad_cook 15.05
TC3218 trad_cook 15.05
MC3021 mod_cook 15.05
MC2222 mod_cook 15.05

Deleted:
title_id type price
-------- ------------ ---------------------
TC7777 trad_cook 14.3279
TC4203 trad_cook 14.595
TC3218 trad_cook 0.0017
MC3021 mod_cook 15.894
MC2222 mod_cook 14.9532
 References
 http://msdn.microsoft.com/en-us/library/ms1
89799(classic).aspx

 http://msdn.microsoft.com/en-us/library/ms3
45415.aspx

 http://msdn.microsoft.com/en-us/library/ms1
80169.aspx