MÓDULO 8

Programando no SQL Server

Prof. Alexandre Siqueira Dias

alexandresd@prof.una.br
Transact-SQL (T-SQL)

Transact-SQL (T-SQL) é um dialeto da

linguagem SQL (Structured Query Language).
Extensão da Microsoft ao padrão SQL-92,
acompanhada de melhorias e recursos, assim
tornando-a exclusiva do SQL Server.
Exemplo em três SGBD’s distintos:

SQL Server: SELECT TOP 10 product, descr, email FROM products 

ORACLE: SELECT product, descr, email FROM products WHERE ROWNUM <= 10

MySQL: SELECT product, descr, email FROM products LIMIT 10

Objetos de programação
 User-defined function (função definida pelo usuário)
 Utilizada para encapsular uma lógica executada frequentemente
 Retorna um valor ou uma tabela
 Stored Procedure (procedimento armazenado)
 Coleção nomeada de instruções Transact-SQL pré-compiladas, executadas
em conjunto
 Implementam uma lógica de negócios diretamente no servidor de banco de
dados, ao invés de no aplicativo
 Possuem parâmetros de entrada e saída
 Podem retornar ou não resultado
 Podem retornar também um “result set” (conjunto de linhas como
resultado)
 Trigger
 Forma especial de uma stored procedure que é executada automaticamente
quando os dados de uma tabela são alterados
Recursos da linguagem Transact SQL

Variáveis
DECLARE
IF...ELSE
WHILE
Tratamento de erros
 Variáveis

As variáveis do T-SQL se dividem em globais

e locais.
Variável global é precedida de @@ em seu
nome e não pode ser definida pelo usuário,
pois a finalidade é retornar informações do
sistema.
Exemplo de variáveis globais:
@@CONNECTIONS: retorna o número de conexões e tentativas
desde que o SQL Server iniciou.
@@ERROR: retorna o código do ultimo erro ocorrido
@@IDENTITY: retorna o ultimo valor Identity inserido
@@ROWCOUNT: retorna o número de linhas do último comando
executado.
 DECLARE

Cria variáveis locais com tipos de dados SQL

Server
As variáveis locais devem iniciar com @
Ex.:
declare @count int, @current_date datetime
declare @msg varchar(255)
Após a declaração, o valor da variável é
NULL
Tipos de Dados

 Numéricos
• Inteiros: int, smallint, tinyint, bigint, bit
• Valores decimais precisos: decimal (p, [s]) ou dec (p,
[s]), numeric(p, [s]), money, smallmoney
• Valores de ponto flutuante: real, float[(p)]
 Datas
• Datetime
• Smalldatetime
 Caracteres
• Tamanho fixo: char(n), nchar(n)
• Tamanho variável: varchar(n), nvarchar(n)
 Inicializando uma variável

Para inicializar uma variável, use SET ou

SELECT
Ex.:
Declare @x int, @date datetime
set @date = getdate()
select @x = datepart(month, @date)
Exibindo o valor de uma variável

Ex.:
declare @x int, @date datetime
set @date = getdate()
set @x = datepart(month, @date)
select @x as x, @date as data_atual
Exibindo o valor de uma variável

Ex.:
use Empresa
GO
declare @count int
select @count = count(*)
from emp
print 'Existem ' + convert(varchar, @count) + '
empregados cadastrados na tabela EMP'
GO
Exibindo o valor de uma variável

Ex.:
use Empresa
GO
declare @count int
set @count = (select count(*) from dept)
print 'Existem ' + convert(varchar, @count) + '
departamentos cadastrados na tabela DEPT'
GO
 IF...ELSE

Comandos condicionais
Ex.:
declare @count int
SELECT @count = COUNT(*)
FROM emp
WHERE deptno = 20
IF @count > 0
print 'Existem ' + convert(varchar, @count) + ' empregados no
departamento 20'
ELSE
print 'Não existem empregados no departamento 20'
GO
 IF...ELSE

Ex.:
USE empresa
GO
IF
(SELECT AVG(salario)
FROM emp
WHERE deptno = 20) > 1000
print 'Média do depto 20 acima de 1000'
ELSE
print 'Média do depto 20 abaixo de 1000'
GO
 WHILE

Comando de repetição
Ex.:
declare @x int, @i int, @msg varchar(40)
set @x = 30
set @i = 0
while @i < @x
set @i = @i + 1
set @msg = 'O valor de @i é igual a ' + convert(varchar,
@i)
print @msg
 Tratamento de Erros

Os erros normalmente eram tratados verificando o valor da

variável global @@ERROR, que guarda o código de erro da
última instrução T-SQL executada.
A partir da versão 2005 existe um mecanismo de tratamento de
erros que consiste na seguinte sintaxe:

BEGIN TRY
...
END TRY

BEGIN CATCH
...
END CATCH
 Tratamento de Erros
Exemplo: tentando inserir um registro com PK duplicada (BD “Formula1”).
BEGIN TRAN

BEGIN TRY

INSERT INTO PILOTO (PILOTO_ID, NOME, PAIS_ORIGEM, PONTOS, EQUIPE_ID)

VALUES (6, 'Nelson Piquet', 'Brasil', NULL, 1)

COMMIT TRAN

END TRY
BEGIN CATCH

ROLLBACK TRAN
SELECT ERROR_NUMBER() AS NumeroErro, ERROR_SEVERITY() AS Severidade,
ERROR_STATE() as Estado, ERROR_MESSAGE() as Mensagem

END CATCH
 Tratamento de Erros
Exemplo: tentando inserir um registro com PK duplicada (BD “Formula1”).
CREATE PROCEDURE st_Insere_Piloto
@piloto_id INT
, @nome VARCHAR(50)
, @pais_origem VARCHAR(50)
, @equipe_id INT
AS
BEGIN

DECLARE @erro VARCHAR(200)

BEGIN TRAN

BEGIN TRY
INSERT INTO PILOTO (PILOTO_ID, NOME, PAIS_ORIGEM, PONTOS, EQUIPE_ID)
VALUES (@piloto_id, @nome, @pais_origem, NULL, @equipe_id)

COMMIT TRAN
END TRY
BEGIN CATCH
SET @erro = 'Erro ao inserir piloto: ' + ERROR_MESSAGE()
ROLLBACK TRAN

RAISERROR (@erro, 16, 1)

END CATCH
END
 Criando funções

Função: rotina armazenada no SQL Server que

retorna um valor
Sintaxe:
CREATE  FUNCTION [ owner_name. ] function_name
    ( [ { @parameter_name [AS] scalar_parameter_data_type [ =
default ] } [ ,...n ] ] )
RETURNS scalar_return_data_type
[ WITH < function_option > [ [,] ...n ] ]
[ AS ]
BEGIN
    function_body
    RETURN scalar_expression
END
 Criando funções

Sintaxe:

CREATE FUNCTION [ owner_name. ] function_name

    ( [ { @parameter_name [AS]
scalar_parameter_data_type [ = default ] } [ ,...n ] ] )
RETURNS TABLE
[ WITH < function_option > [ [,] ...n ] ]
[ AS ]
RETURN [ ( ] select-stmt [ ) ]
 Criando funções

Sintaxe:

CREATE FUNCTION [ owner_name. ] function_name

    ( [ { @parameter_name [AS]
scalar_parameter_data_type [ = default ] } [ ,...n ] ] )
RETURNS @return_variable TABLE < table_type_definition >
[ WITH < function_option > [ [,] ...n ] ]
[ AS ]
BEGIN
    function_body
    RETURN
END
 Criando Funções
create function ft_formata_CPF(@cpf char(11))
returns char(14)
as
begin
declare @result char(14)

set @result = LEFT(@CPF, 3) + '.' +

SUBSTRING(@CPF, 4, 3) + '.' +
SUBSTRING(@CPF, 7, 3) + '-' +
RIGHT(@CPF, 2)
return @result
end
GO

select dbo.ft_formata_CPF('12345678901') as CPF

 Criando Funções

create function ft_Cidade_Paciente (@idPaciente int)

returns varchar(100)
as
begin
declare @cidade varchar(30)

select @cidade = cidade + '/' + estado

from paciente
where idPaciente = @idPaciente
if @cidade is null
set @cidade = 'Paciente não encontrado'

return @cidade
end
 Invocando uma função

declare @cidade varchar(100)

set @cidade = dbo.ft_Cidade_Paciente(100)
print @cidade
ou

select dbo.ft_Cidade_Paciente(100)

ou

select nome
, dbo.ft_Cidade_Paciente(idPaciente) as Cidade
from paciente
 Criando funções
create function Info_Empregado (@CodEmp int)
returns varchar(200)
as
begin
declare @info varchar(200)

select @info = 'Empregado: ' + e.nome + char(13) +

'Departamento: ' + d.nome + char(13) +
'Local: ' + d.loc
from emp e
join dept d
on e.deptno = d.deptno
where e.empno = @CodEmp
if @info is null
set @info = 'Empregado não encontrado'

return @info
end
 Criando funções

create function Func_Maior_Salario(@empno1 int, @empno2 int)

returns int as
begin
declare @sal1 money, @sal2 money, @maior_emp int
set @sal1 = (select salario from emp where empno = @empno1)
set @sal2 = (select salario from emp where empno = @empno2)
if @sal1 > @sal2
set @maior_emp = @empno1
else if @sal2 > @sal1
set @maior_emp = @empno2
else
set @maior_emp = -1
return @maior_emp
end
 Criando funções

select empno, nome, salario, cargo

from emp
where empno = dbo.Func_Maior_salario(7782, 7839)

empno nome salario cargo

----------- -------------------- --------------------- ---------------

7839 KING 5000.0000 PRESIDENTE

(1 row(s) affected)
 Criando funções

Criar uma função que receba como

argumento o código de um
funcionário e que retorne o código,
nome e cargo de todos os
empregados gerenciados por ele.
 Criando funções
create function ft_gerenciados(
@gerente int
)
returns table
as
return
select empno, nome, cargo, deptno
from emp
where gerente = @gerente

go

-- Exemplo de execução
select *
from ft_gerenciados(7839)
 Criando funções

Criar uma função que receba como

argumento um departamento, e que
retorne o código, nome e salário dos
empregados que possuem o maior
salário dentro deste departamento.
 Criando funções
create function ft_empMaiorSal(@deptno int)
returns table
as
return
select empno, nome, salario
from emp
where deptno = @deptno
and salario = (
select max(salario)
from emp
where deptno = @deptno
)
go

select *
from ft_empMaiorSal(20)
 Criando funções

Criar uma função que receba como parâmetro uma

data base, e que retorne o início e fim do semestre
letivo, de acordo com a seguinte regra:
-Se o mês da data for menor ou igual a junho, as
datas retornadas serão 01/01/ano_data a
30/06/ano_data
-Senão retornar 01/07/ano_data a 31/12/ano_data
 Criando funções
create function ft_periodo_letivo(@data_base datetime)
returns @periodo_letivo table(
data_inicio_periodo datetime,
data_fim_periodo datetime
)
as
begin
declare @data_inicio datetime
, @data_fim datetime

if month(@data_base) <= 6
begin
set @data_inicio = '01.01.' + CAST(YEAR(@data_base) as varchar)
set @data_fim = '30.06.' + CAST(YEAR(@data_base) as varchar)
end else
begin
set @data_inicio = '01.07.' + CAST(YEAR(@data_base) as varchar)
set @data_fim = '31.12.' + CAST(YEAR(@data_base) as varchar)
end

insert into @periodo_letivo

values(@data_inicio, @data_fim)

return
end
go

select *
from ft_periodo_letivo(GETDATE())
 Criando funções
create function GetSugestaoPalavra(@palavra varchar(30))
returns @tabPalavras table (nome varchar(30))
as
begin
insert into @tabpalavras
select nome
from dicionario
where nome = @palavra

if (select count(*)
from @tabpalavras) = 0
begin
insert into @tabpalavras
select nome
from dicionario
where soundex(nome) = soundex(@palavra)
end
return
end
 Criando funções
Criar uma função que receba como primeiro
argumento o código de um departamento e como
segundo argumento um inteiro:
1 - retornar empregados com maior salário
2 - retornar empregados com menor salário

Retornar o código, nome e cargo destes empregados.

 Criando funções
create function GetEmpregados(@deptno int, @opcao int)
returns @empregados table (empno int, nome varchar(20), cargo varchar(20))
as
begin
declare @max money, @min money

select @max = max(salario), @min = min(salario)

from emp
where deptno = @deptno

if (@opcao = 1)
insert into @empregados
select empno, nome, cargo from emp
where deptno = @deptno

and salario = @max

else if (@opcao = 2)
insert into @empregados
select empno, nome, cargo from emp
where deptno = @deptno
and salario = @min
return
end
 Criando funções
Criar uma função que receba como primeiro argumento
o código de um departamento e como segundo
argumento um inteiro:
1 - retornar empregados com salário acima da média
2 - retornar empregados com salário abaixo da média
Retornar o código, nome e cargo destes empregados.
 Criando funções
create function GetEmpregadosMedia(@deptno int, @opcao int)
returns @empregados table (codemp int, nome varchar(20), cargo varchar(20))
as begin
declare @media money

select @media = avg(salario)

from emp
where deptno = @deptno

if (@opcao = 1)
insert into @empregados
select empno, nome, cargo
from emp
where deptno = @deptno
and salario > @media
else if (@opcao = 2)
insert into @empregados
select empno, nome, cargo
from emp
where deptno = @deptno
and salario < @media
return
end
 Criando stored procedures
CREATE PROC [ EDURE ] procedure_name [ ;
number ]
    [ { @parameter data_type }
         [ = default ] [ OUTPUT ] ] [ ,...n ]
[ WITH
    {ENCRYPTION} ]

AS sql_statement [ ...n ]
 Criando stored procedures
Ex.:
use Empresa
GO
CREATE PROCEDURE emp20
AS
SELECT * FROM emp WHERE deptno = 20
GO
 Executando stored procedures

Executando um procedimento
armazenado isoladamente
EXEC[UTE] emp20
Executando um procedimento
armazenado em uma instrução INSERT
INSERT INTO emp_temp
EXEC emp20
 Alterando e descartando stored
procedures

Alterando stored procedures

 Não afeta as stored procedures aninhadas
ALTER PROCEDURE emp20
AS
SELECT * FROM emp
WHERE deptno = 20 and salario > 1000
Descartando stored procedures
DROP PROCEDURE emp20
 Utilizando parâmetros
USE pubs
GO
CREATE PROCEDURE au_info
@lastname varchar(40),
@firstname varchar(20) AS
SELECT au_lname, au_fname, title, pub_name
FROM authors a INNER JOIN titleauthor ta
ON a.au_id = ta.au_id INNER JOIN titles t
ON t.title_id = ta.title_id INNER JOIN publishers p
ON t.pub_id = p.pub_id
WHERE au_fname = @firstname
AND au_lname = @lastname
GO
 Utilizando parâmetros
EXECUTE au_info 'Dull', 'Ann'
-- Ou
EXECUTE au_info @lastname = 'Dull', @firstname = 'Ann'
-- Ou
EXECUTE au_info @firstname = 'Ann', @lastname = 'Dull'
 Utilizando parâmetros
USE pubs
GO
CREATE PROCEDURE au_info2
@lastname varchar(30) = 'D%',
@firstname varchar(18) = '%' AS
SELECT au_lname, au_fname, title, pub_name
FROM authors a INNER JOIN titleauthor ta
ON a.au_id = ta.au_id INNER JOIN titles t
ON t.title_id = ta.title_id INNER JOIN publishers p
ON t.pub_id = p.pub_id
WHERE au_fname LIKE @firstname
AND au_lname LIKE @lastname
GO
 Utilizando parâmetros
EXECUTE au_info2
-- Ou
EXECUTE au_info2 'Wh%'
-- Ou
EXECUTE au_info2 @firstname = 'A%'
-- Ou
EXECUTE au_info2 'Hunter', 'Sheryl'
-- Ou
EXECUTE au_info2 'H%', 'S%'
 Utilizando parâmetros de saída
USE pubs
GO
CREATE PROCEDURE titles_sum
@TITLE varchar(40) = '%',
@SUM money OUTPUT
AS
SELECT title
FROM titles
WHERE title LIKE @TITLE
SELECT @SUM = SUM(price)
FROM titles
WHERE title LIKE @TITLE
GO
 Utilizando parâmetros de saída
DECLARE @TOTALCOST money
EXECUTE titles_sum 'The%', @TOTALCOST OUTPUT
SELECT 'O custo total desses livros é $'
+ CAST(@TOTALCOST AS varchar(20))

Title
--------------------------------------------------------------------------------
The Busy Executive's Database Guide
The Gourmet Microwave
The Psychology of Computer Cooking
(3 row(s) affected)
-------------------------------------------------------------
O custo total desses livros é $22.98
(1 row(s) affected)
 Criando Triggers
Tipo específico de stored procedure
 Associado a uma tabela
 Executada automaticamente após
 UPDATE
 INSERT
 DELETE
 Não podem ser chamados diretamente
 É parte de uma transação
 Criando Triggers
Criadas para
 Alterações em cascata em tabelas
relacionadas de um banco de dados
 Impor uma integridade de dados mais
complexa do que uma restrição CHECK
 Comparar os estados anteriores e
posteriores dos dados que estão sendo
modificados
 Criando Triggers
As constraints são verificadas
primeiro
A operação (INSERT, UPDATE,
DELETE) é executada
A trigger é disparada
As tabelas podem conter várias
triggers para uma mesma ação
 Criando Triggers
Sintaxe
create trigger [owner.]trigger_name
on [owner.]table_name
for {insert, update, delete}
as SQL_statements
 Criando Triggers
Sintaxe
create trigger [owner.]trigger_name
on [owner.]table_name
for {insert, update}
as
[if update (column_name )
[{and | or} update
(column_name)]...]
SQL_statements
 Criando Triggers
Exemplo
create trigger tr_dept on dept
for insert as
print 'Linha inserida'
GO
insert into dept (deptno, nome)
values (70, 'RH')
GO
Linha inserida
(1 row(s) affected)
 Alterando Triggers
Exemplo
alter trigger tr_dept on dept
for update as
if update(nome)
print 'Nome alterado'
else if update(loc)
print 'Local alterado'
GO
update dept
set nome = 'FIN'
where deptno = 70
GO

Nome alterado
(1 row(s) affected)
 Criando Triggers
Tabelas INSERTED e DELETED
 Tabelas especiais utilizadas em instruções de
triggers
 SQL Server automaticamente cria e gerencia
essas tabelas
 Tabelas temporárias, em memória, utilizadas
para testar os efeitos das alterações
realizadas
 Não podem ser alteradas
 Criando Triggers
Tabelas INSERTED e DELETED
 Criando Triggers
Tabelas INSERTED e DELETED

CREATE TRIGGER tr_EMP ON emp

FOR INSERT, UPDATE, DELETE AS
PRINT 'Inserted:'
SELECT empno, nome, salario, deptno
FROM inserted
PRINT 'Deleted:'
SELECT empno, nome, salario, deptno
FROM deleted
 Criando Triggers
insert into emp (empno, nome, salario, deptno)
values (8000, 'Stephen', 2000, 70)
GO

Inserted:
empno nome salario deptno
----------- ------------------ --------------------- -----------
8000 Stephen 2000.0000 70

(1 row(s) affected)

Deleted:
empno nome salario deptno
--------- -------------------- --------------------- -----------

(0 row(s) affected)
 Criando Triggers
insert into emp (empno, nome, salario, deptno)
values (9000, 'Mary', 1400, 70)
GO

Inserted:
empno nome salario deptno
----------- ------------------ --------------------- -----------
9000 Mary 1400.0000 70

(1 row(s) affected)

Deleted:
empno nome salario deptno
--------- -------------------- --------------------- -----------

(0 row(s) affected)
 Criando Triggers
update emp
set salario = salario * 1.5
where deptno = 70
GO
Inserted:
empno nome salario deptno
----------- -------------------- --------------------- -----------
8000 Stephen 3000.0000 70
9000 Mary 2100.0000 70
(2 row(s) affected)

Deleted:
empno nome salario deptno
----------- -------------------- --------------------- -----------
8000 Stephen 2000.0000 70
9000 Mary 1400.0000 70
(2 row(s) affected)
 Criando Triggers
delete from emp
where deptno = 70
GO
Inserted:
empno nome salario deptno
--------- -------------------- --------------------- -----------

(0 row(s) affected)

Deleted:
empno nome salario deptno
--------- -------------------- --------------------- -----------
8000 Stephen 3000.0000 70
9000 Mary 2100.0000 70

(2 row(s) affected)
Alterando dados na tabela base utilizando
as tabelas INSERTED e DELETED
alter trigger tr_emp on emp
for insert as
update emp
set comissao = salario*0.10
where empno in
(select empno from inserted)
Alterando dados na tabela base utilizando
as tabelas INSERTED e DELETED
insert into emp (empno, nome, salario, deptno)
values (9000, 'Mary', 1400, 70)
GO
select empno, salario, comissao
from emp
where empno = 9000
GO

(1 row(s) affected)

empno salario comissao

----------- --------------------- ---------------------
9000 1400.0000 140.0000

(1 row(s) affected)
Alterando dados na tabela base utilizando
as tabelas INSERTED e DELETED
ALTER TRIGGER tr_EMP ON emp
FOR UPDATE AS
DECLARE @NEW_SAL money, @OLD_SAL money
select @NEW_SAL = salario
from inserted

select @OLD_SAL = salario

from deleted

if @NEW_SAL < @OLD_SAL

begin
raiserror('Não é possível diminuir o salário do empregado', 16, 1)
rollback
end
Alterando dados na tabela base utilizando
as tabelas INSERTED e DELETED
update emp
set salario = 1000
where empno = 9000

Msg 50000, Level 16, State 1, Procedure tr_EMP, Line 12

Não é possível diminuir o salário do empregado
Msg 3609, Level 16, State 1, Line 2
The transaction ended in the trigger. The batch has been aborted.
 Exercícios (Trigger)
Execute o seguinte script no banco de dados EMPRESA:

ALTER TABLE DEPT

ADD ATIVO INT
GO

UPDATE DEPT
SET ATIVO = 1
GO
 Exercícios (Trigger)
Crie uma trigger na tabela DEPT, de
maneira que não seja possível
inativar um departamento (campo ATIVO =
0), caso exista algum empregado neste
departamento
 Exercícios (Trigger)
create trigger TR_UPD_ATIVO_DEPT on dept
for UPDATE as
declare @deptno varchar(10)
if update(Ativo)
begin
select @deptno = e.deptno
from inserted I
join emp e
on i.deptno = e.deptno
where i.ativo = 0

if @deptno is not null

begin
raiserror ('Não é possível desativar um departamento com empregados (%s)',16, 1, @deptno)
rollback
end
end
 Exercícios (Trigger)
Crie uma trigger na tabela EMP, de maneira que não seja
possível alterar o departamento do empregado para um
departamento inativo, e que também não permita inserir
um empregado em um departamento inativo.
 Exercícios (Trigger)
create trigger TR_ATIVO_EMP on EMP
for update, insert
as
declare @msg varchar(100)
if update(deptno)
begin
if exists(select empno
from inserted i
join dept d
on i.deptno = d.deptno
where d.ativo = 0)
begin
if exists(select empno from deleted)
set @msg = 'Não é possível transferir um empregado para um departamento inativo'
else
set @msg = 'Não é possível incluir um empregado em um departamento inativo'
raiserror(@msg, 16, 1)
rollback
end
end
 Trabalhando com cursores
Conjunto de linhas retornadas por uma
instrução SELECT, sobre o qual é
permitido realizar operações baseadas
nas linhas retornadas
É possível processar os dados, linha a
linha
 Trabalhando com cursores
Componentes
 Declarar - DECLARE
 Abrir - OPEN
 Buscar - FETCH
 Fechar ou desalocar - CLOSE ou
DEALOCATE
 Declarando cursores
Sintaxe básica

DECLARE cursor_name
[ INSENSITIVE ] [ SCROLL ] CURSOR
FOR select_statement
 Declarando cursores
Exemplo

DECLARE crsr_emp CURSOR

FOR
select *
from emp
where deptno = 30
 Abrindo cursores
Sintaxe
OPEN [GLOBAL] cursor_name
Abre o cursor e povoa o cursor
executando a instrução SELECT
especificada na declaração do cursor
Exemplo:
OPEN crsr_emp
 Buscando (FETCH) cursores
Sintaxe
FETCH
        [ [ NEXT | PRIOR | FIRST | LAST
                | ABSOLUTE { n | @nvar }
                | RELATIVE { n | @nvar }
            ]
            FROM
        ]
{ [ GLOBAL ] cursor_name }
[ INTO @variable_name [ ,...n ] ]

Obtém uma linha específica do cursor

 Buscando (FETCH) cursores
Exemplos:
FETCH next from crsr_emp
ou
FETCH next from crsr_emp
into @empno, @nome, @salario, @deptno
Fechando (CLOSE) e desalocando
(DEALLOCATE) cursores
Após o processamento, o cursor deve ser fechado e
desalocado
CLOSE: fecha o cursor, mas não libera estruturas de
dados utilizadas. Utilizado quando se deseja reabrir o
cursor
DEALLOCATE: fecha o cursor e libera estruturas de
dados utilizadas.
Exemplo:
CLOSE crsr_emp
DEALLOCATE crsr_emp
 Funções de cursores
@@cursor_rows: exibe a quantidade de linhas do
cursor
@@fetch_status: exibe o status do último comando
FETCH
 0: bem sucedido
 -1: a busca falhou ou fez com que o cursor fosse além do
conjunto de resultados
Exemplo:
while @@fetch_status = 0
... bloco_comandos
 Criando cursores
DECLARE @empno int, @nome varchar(50), @i int
set @i = 0
DECLARE crsr_emp CURSOR
FOR
select empno, nome
from emp
where deptno = 10
order by nome desc

OPEN crsr_emp

Print 'O cursor possui ' + convert(varchar, @@cursor_rows) + ' linhas '
Print ''

fetch next from crsr_emp

into @empno, @nome

while @@fetch_status = 0
begin
set @i = @i + 1
print 'Estamos na posicao ' + convert(varchar, @i) + ' do cursor'
print 'Empno ' + convert(varchar, @empno) + ', nome ' + convert(varchar, @nome)
Print ''
fetch next from crsr_emp
into @empno, @nome
end

close crsr_emp
deallocate crsr_emp