SQL Desenvolvimento

Locadora de Veiculos
Tabela Pessoa Fisica

create table PessoaFisica

(
idPessoaFisica int not null PRIMARY KEY,
Nome VarChar(60) not null,
Cpf VarChar(14) not null,
Rg Varchar(12) not null,
Sexo Varchar (9) not null,
Endereco VarChar (60) not null,
Tel Varchar (10) null,
Cel Varchar (10) null,
Passaporte Varchar(8) not null,
DtNasc VarChar(10) not null,
NumCnh VarChar(11) not null,
Categoria VarChar(5) not null,
ValidadeCnh VarChar(10) not null
) ENGINE=InnoDB;

Clausula Select:
Begin
Select Nome, Cpf, Rg, Chassi, Placa, dataDevolucao, valorTotal
From Devolucao
Inner Join PessoaFisica ON
(PessoaFisica.idPessoaFisica=Devolucao.idPessoaFisica)
Inner join Veiculo ON (veiculo.idVeiculo=Devolucao.idVeiculo)
Order By PessoaFisica.Nome;
End;

Clausula Insert:

Insert Into PessoaFisica Values(1,'Leonardo Andrade','328.129.398

00','42.517.339-2','Masculino','R. Heitor Ferrari 45 - Porto
Novo','1238885053','1151071934','32586622','17/11/1984','12345678911','A'
,'10/10/2015');

Clausula Update:
Update PessoaFisica Set Passaporte='10105522', Cel='1163085131'
where idPessoaFisica = 2;

Clausula Delete:
Begin
delete PessoaFisica where idPessoaFisica=3;
End;

Índice não Clusterizado:

Create Index IDX_PessoaFisica_Categoria
ON PessoaFisica(Categoria);

Indice Clusterizado:
Create CLUSTERED Index IDX_PessoaFisica_Cnh
ON PessoaFisica(ValidadeCnh);

Tabela Veiculo

create table Veiculo

(
idVeiculo int not null Primary Key,
kmRodado int not null,
tarifaLocKm Float not null,
tarifaLocKmLiv Float not null,
chassi Varchar(17) not null,
placa Varchar(8) not null,
cidade Varchar(30) not null,
estado Varchar(30) not null,
modelo Varchar(30) not null,
fabricante Varchar(30) not null,
cor Varchar(30) not null,
valorDiario Float not null
) ENGINE=InnoDB;

insert into Veiculo values(1,200,99.90,90.90,'9BWHE21JX24060960','1123-

CBA','São Paulo','São Paulo','Gol','VolksWagen','Verde',45.50);

Tabela Locação

create table Locacao

(
idLocacao int not null AUTO_INCREMENT,
idVeiculo int not null,
idPessoaFisica int not null,
 localLocacao VarChar(40) not null,
dataLocacao Varchar(10) not null,
horaLocacao Varchar(10) not null,
kmLocacao int not null,
cidade Varchar(20) not null,
estado Varchar(20) not null,
pais Varchar(30) not null,
diasLocacao int not null,
PRIMARY KEY(idLocacao)
ALTER TABLE Locacao ADD FOREIGN KEY (idPessoaFisica)
REFERENCES PessoaFisica (idPessoaFisica);
ALTER TABLE Locacao ADD FOREIGN KEY (idVeiculo)
REFERENCES Veiculo (idVeiculo);
ON DELETE CASCADE) ENGINE=InnoDB;

Insert Into Locacao Values (1,1,1,'R. Nove de

Julho','06/10/2013','14:00',200,'São Paulo','São Paulo','Brasil',5);

Tabela Devolução

create table Devolucao

(
idDevolucao int not null AUTO_INCREMENT,
idLocacao int not null,
idVeiculo int not null,
idPessoaFisica int not null,
localDevolucao Varchar(40) not null,
dataDevolucao Varchar(10) not null,
horaDevolucao Varchar(8) not null,
agenciaDevolucao Varchar(40) not null,
valorTotal Float not null,
Primary Key(idDevolucao)
ALTER TABLE Devolucao ADD FOREIGN KEY (idPessoaFisica)
REFERENCES PessoaFisica (idPessoaFisica)
ALTER TABLE Devolucao ADD FOREIGN KEY (idLocacao)
REFERENCES Locacao (idLocacao)
ALTER TABLE Devolucao ADD FOREIGN KEY (idVeiculo)
REFERENCES Veiculo (idVeiculo)
ON DELETE CASCADE) ENGINE=InnoDB;

Insert into Devolucao values(1, 1, 1, 1,'R. Nove de

Julho','06/11/2013','17:00', 'SP LOCATE CAR', 227.50);

PLSQL
A PLSQL é uma linguagem estrutural estendida da SQL que tem por objetivo auxiliar as
tarefas de programação no Oracle. Ela incorpora à SQL características procedurais, como
os benefícios e facilidades de controle de fluxo de programas que as melhores linguagens
possuem. Por exemplo loops estruturados (for, while) e controle de decisão (if then else).
PL/SQL significa "Procedural Language extensions to SQL", que pode ser usado em
bancos de dados. O PL/SQL é a linguagem SQL com construções de programação similares
a outras liguagens, principalmente com a linguagem Pascal.

Constantes:

Para declarações de constantes, a palavra CONSTANT deve aparecer antes do tipo de

dado e a seguir utiliza-se o operador := para atribuir-lhe um valor.

Delimitadores

Delimitador Ponto e vírgula (;)

Indica o final de um comando
IF salario < min_salario
THEN
salario := salario + salario * .25;
END IF;

Comentário de uma única linha

IF salario < min_salario(1994) -- retorna min salário do ano

THEN
salario := salario * .25;
END IF

Comentário de múltiplas linhas

PROCEDUREcalcula_receita (empresa IN NUMBER) IS

/* Programa alterado em 23/9/94
Analista Responsável: Manoel de Souza * /

Seções de um bloco

Cabeçalho (Header)
determina o modo como o bloco deve ser chamado
Seção de Declaração
onde declaramos variáveis, cursores e sub-blocos e
seções de exceção
Seção de Execução
parte que contém o código a ser executado
Seção de Exceções (Exceptions)
manipula exceções ao processamento normal
(condições de aviso e erro).

Seções de um Bloco

Cabeçalho
IS
Seção de declaração
Begin
Seção de execução
Exception
Seção de exceptions
End;

Seções de um Bloco
Blocos Anônimos

Não possuem nome

Declare
Seção de declaração
Begin
Seção de execução
Exception
Seção de exceptions
End;

Exemplo:

DECLARE
pi CONSTANT NUMBER(9,7) := 3.1415927;
...
BEGIN
...
END;

Exemplo 1 IF Else:

DECLARE
V_1 NUMBER(2) := 4;
V_2 VARCHAR2(5);
BEGIN
IF MOD(V_1,2) = 0
THEN V_2 := 'PAR';
ELSE V_2 := 'IMPAR';
END IF;
DBMS_OUTPUT.PUT_LINE ('O número é: ' || V_2);
END;

NOTA: MOD(V1,2) divide o valor de V_1 por 2 e retorna o resto da divisão.

Exemplo 2 IF Else:

CREATE TABLE ALUNO (

RA NUMBER(9),
NOTA NUMBER(3,1));
 INSERT INTO ALUNO VALUES (1,4);

DECLARE
V_RA ALUNO.RA%TYPE := 1;
V_NOTA ALUNO.NOTA%TYPE;
V_CONCEITO VARCHAR2(12);
BEGIN
SELECT NOTA
INTO V_NOTA
FROM ALUNO
WHERE RA = V_RA;
IF V_NOTA <= 5
THEN V_CONCEITO := 'REGULAR';
ELSE IF V_NOTA < 7
THEN V_CONCEITO := 'BOM';
ELSE V_CONCEITO := 'EXCELENTE';
END IF;
DBMS_OUTPUT.PUT_LINE ('Conceito: ' || V_CONCEITO);
END;

Exemplo Case:

DECLARE
V_RA ALUNO.RA%TYPE := 1;
V_NOTA ALUNO.NOTA%TYPE;
V_CONCEITO VARCHAR2(12);
BEGIN
SELECT NOTA
INTO V_NOTA
FROM ALUNO
WHERE RA = V_RA;
V_CONCEITO :=
CASE
WHEN V_NOTA <= 5 THEN 'REGULAR'
WHEN V_NOTA < 7 THEN 'BOM'
ELSE 'EXCELENTE'
END;
DBMS_OUTPUT.PUT_LINE ('Conceito: ' || V_CONCEITO);
END;

INSTRUÇÕES LOOP, FOR E WHILE

Exemplo 1:
DECLARE
V_AUX NUMBER(2) := 0;
BEGIN
FOR V_CONTADOR IN 1..10
LOOP
V_AUX := V_AUX +1;
DBMS_OUTPUT.PUT_LINE (V_AUX);
END LOOP;
END;

Exemplo 2:
DECLARE
V_RA_INICIAL ALUNO.RA%TYPE := 1;
V_RA_FINAL V_RA_INICIAL%TYPE;
V_AUX V_RA_INICIAL%TYPE := 0;
BEGIN
SELECT COUNT(RA)
INTO V_RA_FINAL
FROM ALUNO;
FOR V_CONTADOR IN V_RA_INICIAL..V_RA_FINAL
LOOP
V_AUX := V_AUX +1;
DBMS_OUTPUT.PUT_LINE ('Total de alunos: ' || V_AUX);
END LOOP;
END;

While

Exemplo 1:
DECLARE
V_RA_INICIAL ALUNO.RA%TYPE := 1;
V_RA_FINAL V_RA_INICIAL%TYPE;
V_AUX V_RA_INICIAL%TYPE := 0;
BEGIN
SELECT COUNT(RA)
INTO V_RA_FINAL
FROM ALUNO;
FOR V_CONTADOR IN V_RA_INICIAL..V_RA_FINAL
LOOP
V_AUX := V_AUX +1;
DBMS_OUTPUT.PUT_LINE ('Total de alunos: ' || V_AUX);
END LOOP;
END;

Exemplo 2:
DECLARE
V_RA_FINAL ALUNO.RA%TYPE := 1;
V_AUX V_RA_FINAL%TYPE := 0;
BEGIN
SELECT COUNT(RA)
INTO V_RA_FINAL
FROM ALUNO;
WHILE V_AUX < V_RA_FINAL
LOOP
V_AUX := V_AUX +1;
DBMS_OUTPUT.PUT_LINE ('Total de alunos: ' || V_AUX);
END LOOP;
END;

EXIT:

Exemplo 1:

DECLARE
 V_AUX NUMBER(2) := 0;
BEGIN
FOR V_CONTADOR IN 1..15
LOOP
V_AUX := V_AUX +1;
DBMS_OUTPUT.PUT_LINE (V_AUX);
EXIT WHEN V_CONTADOR = 10;
END LOOP;
END;

Exemplo 2:
DECLARE
V_AUX NUMBER(2) := 0;
BEGIN
FOR V_CONTADOR IN 1..15
LOOP
V_AUX := V_AUX +1;
DBMS_OUTPUT.PUT_LINE (V_AUX);
IF V_CONTADOR = 10
THEN EXIT;
END IF;
END LOOP;
END;

LOOP
Executa uma relação de comandos até que uma instrução de saída (EXIT) seja
encontrada.

Exemplo:
DECLARE
V_AUX NUMBER(2) := 0;
BEGIN
LOOP
V_AUX := V_AUX +1;
DBMS_OUTPUT.PUT_LINE (V_AUX);
IF V_AUX = 10
THEN EXIT;
END IF;
END LOOP;
END;

View
Uma view é uma maneira alternativa de observação de dados de uma ou
mais entidades (tabelas), que compõem uma base de dados. Pode ser considerada
como uma tabela virtual ou uma consulta armazenada. Geralmente e recomendável,
uma view, implementada encapsulando uma instrução SELECT (busca de dados para
exposição), guarda os dados em uma tabela virtual, armazenando também em cache,
pois todas as consultas ao banco, encapsuladas ou não, ao serem executadas, são
armazenadas em cache. Por este motivo, pode ser mais rápido ter uma consulta
armazenada em forma de view, em vez de ter que retrabalhar uma instrução.
As views nos possibilitam mais que simplesmente visualizar dados. Elas podem ser
implementadas também com algumas aplicações de restrição:

Seleciona quatro campos da tabela pessoa fisica e demonstra em uma view:

CREATE VIEW V_PessoaFisica

AS SELECT Nome, Cpf, Rg, Sexo
FROM PessoaFisica;

Seleciona informações da tabela Veiculos e apresenta em uma View:

CREATE VIEW V_Veiculo

AS SELECT modelo, fabricante, cor, valorDiario
FROM Veiculo;

Seleciona quatro campos da junção entre três tabelas de acordo com a chave e demonstra
em uma view:

Create View V_Locacao

As
Select Nome, modelo, diasLocacao, valorDiario
From PessoaFisica
Inner Join Locacao ON(PessoaFisica.idPessoaFisica=Locacao.idPessoaFisica)
Inner Join Veiculo ON(Veiculo.idVeiculo=Locacao.idVeiculo);

Seleciona campos através da junção entre as tabelas Devolucao,

PessoaFisica e Veiculo:

Create View V_Devolucao

As
Select Nome, Cpf, Rg, Chassi, Placa, dataDevolucao, valorTotal
From Devolucao
Inner Join PessoaFisica ON
(PessoaFisica.idPessoaFisica=Devolucao.idPessoaFisica)
Inner join Veiculo ON (veiculo.idVeiculo=Devolucao.idVeiculo);

Procedure
Definição de Procedure: Sub-rotina que processa informações e não retorna valor,
Procedure ou Procedimento é um trecho de código separado para executar uma
determinada tarefa, um determinado comportamento, e após a sua execução deve
retornar uma linha imediatamente abaixo de onde esta procedure foi invocada.

Procedure para pesquisar informações sobre o aluno de acordo com o seu Ra ( Parâmetro
informado @ra (Select)):

Create Procedure spPesqRa

@ra int
As
Begin
Select*From Aluno Where Ra = @ra
End

Procedure para buscar todos os alunos em ordem decrecente (Select):

Create Procedure spOrdDec

As
Select Ra,Nome
From Aluno
Order By Ra Desc

Procedure para trazer o aluno pelo Ra e Nome com Multiplos Parâmetros(Select):

Create Procedure spMultiplosParam

@ra int,
@nome Varchar(60)
As
Begin
Select*From Aluno Where Ra=@ra and Nome=@nome
End

Procedure para cadastrar aluno com multiplos parâmetros (Insert):

Create Procedure spInsereAluno

@ra int,
@nome Varchar(60)
As
Begin
Insert into Aluno(Ra,Nome)Values(@ra,@nome);
End

Procedure para alterar o nome do aluno através da passagem do parâmetro id:

Create Procedure spAlterarAluno

@ra int,
@nome VarChar(60)
As
Begin
Update Aluno Set Nome=@nome Where Ra=@ra;
End

Procedure para deletar registro através do Ra do aluno:

Create Procedure spDeletarAluno

@ra int
As
Begin
Delete Aluno Where Ra=@ra
End
 Functions

Definição de Functions: Sub-rotina que processa informações e retorna um valor, Uma

Function pode receber nenhum, um ou vários parâmetros de entrada e retornar um
determinado valor.

Exemplos:

A – Tipo de função: Scalar-valued user-defined function:

CREATE FUNCTION TRIM(@ST VARCHAR(1000))

RETURNS VARCHAR(1000)
BEGIN
RETURN(LTRIM(RTRIM(@ST)))
END

B – Invocando uma Scalar-valued user-defined function:

SELECT'>'+DBO.TRIM(' WELLYNGTON MOREIRA ')+'<'

2 – Deseja-se uma tabela com os registros de todos os tempos possíveis em intervalos de

minutos parametrizáveis entre duas datas quaisquer.

Como o problema requer o retorno de datas em intervalos de minutos, vamos criar uma
tabela em nossa função com um campo do tipo DATETIME, utilizando a função built-in
(função interna do SQL Server) DATEADD() para incrementar uma data inicial até a data
final desejada em intervalos de minutos = MINUTE.

A – Tipo de função: Multi-statement table-valued function:

CREATE FUNCTION DtsMinutos(@min int, @dti datetime, @dtf datetime)

RETURNS @tbl TABLE(dt datetime)
AS
BEGIN
WHILE @dti
BEGIN
INSERT INTO @tbl(dt) VALUES (@dti)
SET @dti = DATEADD(MINUTE,@min,@dti)
END
RETURN
END

B – Invocando uma Multi-statement table-valued function:

SELECT * FROM DtsMinutos(12,'2011-01-01 12:00','2011-01-01 17:00')

3 – Deseja-se uma tabela com os FUNCIONÁRIOS contratados após uma data
específica. Para este problema vamos supor uma tabela povoada com três atributos: A
matrícula do tipo int, o nome do tipo varchar(80) e dataContratacao do tipo dateTime com
a data que o funcionáio foi contratado.

A – Tipo de função: Inline table-valued function:

CREATE FUNCTION funcionariosApos(@dt datetime)

RETURNS TABLE
AS
RETURN (SELECT *
FROM FUNCIONARIO
WHERE dataContratacao >= @dt)

B – Invocando uma Multi-statement table-valued function:

SELECT * FROM funcionariosApos('2000-01-01')

Triggers
Gatilho ou trigger é um recurso de programação executado sempre que o evento
associado ocorrer. Trigger é um tipo especial de procedimento armazenado, que é
executado sempre que há uma tentativa de modificar os dados de uma tabela que é
protegida por ele.
É muito utilizada para ajudar a manter a consistência dos dados ou para propagar
alterações em um determinado dado de uma tabela para outras. Um bom exemplo é um
gatilho criado para controle de quem alterou a tabela, nesse caso, quando a alteração for
efetuada, o gatilho é "disparado" e grava em uma tabela de histórico de alteração, o
usuário e data/hora da alteração.
Em SQL, um gatilho típico é composto de três componentes, que seguem o Modelo
evento - condição - ação

Índices

Os índices ajudam-nos a obter mais rapidamente dados das tabelas. Usemos um

exemplo para ilustrar este ponto: Digamos que estamos interessados em ler sobre como
cultivar pimentos num livro de jardinagem. Em vez de lermos o livro do início ao fim até
encontrarmos uma secção sobre pimentos, é muito mais fácil utilizar a secção do índice
no final do livro, localizar as páginas que contêm informações sobre pimentos e, em
seguida, consultar diretamente essas páginas. Consultar primeiro o índice permite poupar
tempo e é o método mais eficiente para localizar as informações necessárias.
O mesmo princípio é aplicável para a obtenção de dados a partir de uma tabela de base
de dados. Sem um índice, o sistema da base de dados lê toda a tabela (este processo é
denominado 'pesquisa da tabela') para localizar as informações pretendidas. Através de
um índice adequado, o sistema da base de dados pode percorrer primeiro o índice para
descobrir onde obter os dados e, em seguida, aceder diretamente aos locais para obter os
dados necessários. Assim é muito mais rápido.

Como tal, muitas vezes é preferível criar índices nas tabelas. Um índice pode abranger
uma ou mais colunas. A sintaxe geral para criar um índice é:

Exemplos com indices:

Tabela tbl_usuario:

Create Table tbl_usuario

(
usuario_cpf decimal(10,0) not null primary key,
usuario_nome Varchar(128) not null,
usuario_email Varchar(128) not null,
usuario_telefone decimal(10,0) not null
)
Go

Comando para Verificação de alocações de páginas de índices:

DBCC CHECKALLOC
GO

Procedimento armazenado do sistema para verificação de índices:

EXEC SP_HELPINDEX @objname = tbl_usuario

GO

Consulta a tabela sysindexes:

Select name, keys, root, indid FROM sysindexes

Where name='PK__tbl_usua__8C05FC197F60ED59'
GO

Índice não Clusterizado:

Create Index IDX_PessoaFisica_Categoria
ON PessoaFisica(Categoria);

Indice Clusterizado:
Create CLUSTERED Index IDX_PessoaFisica_Cnh
ON PessoaFisica(ValidadeCnh);

DeadLock
Um deadlock acontece quando duas ou mais tarefas bloqueiam uma à outra
permanentemente, sendo que cada uma tem o bloqueio de um recurso, que a outra tarefa
está tentando bloquear. Por exemplo:
 A transação A adquire um bloqueio compartilhado da linha 1.
 A transação B adquire um bloqueio compartilhado da linha 2.
 A transação A agora solicita um bloqueio exclusivo na linha 2 e é bloqueado até
que a transação B termine e libere o bloqueio compartilhado que tem na linha 2.
 A transação B agora solicita um bloqueio exclusivo na linha 1 e é bloqueado até
que a transação A termine e libere o bloqueio compartilhado que tem na linha 1.
A transação A não pode terminar até que a transação B termine, mas a transação B está
bloqueada pela transação A. Essa condição é também chamada de dependência cíclica:
a transação A tem uma dependência da transação B, e a transação B fecha o círculo
tendo uma dependência da transação A.
Ambas as transações em um deadlock esperarão indefinidamente, a menos que o
deadlock seja quebrado por um processo externo. O monitor de deadlock do
Microsoft Mecanismo de banco de dados do SQL Server verifica periodicamente as
tarefas que estão em um deadlock. Se o monitor detectar uma dependência cíclica, ele
escolhe uma das tarefas como vítima e termina sua transação com um erro. Isso permite
que a outra tarefa complete sua transação. O aplicativo com a transação que terminou
com um erro pode repetir a transação, a qual normalmente é concluída depois que a outra
transação em deadlock é encerrada.
Usando certas convenções de codificação em aplicativos reduz a chance de que os
aplicativos causarão deadlocks. Para obter mais informações, consulte Minimizando
deadlocks.
O deadlock é freqüentemente confundido com bloqueio normal. Quando uma transação
solicita um bloqueio em um recurso bloqueado por outra transação, a transação solicitante
espera até que o bloqueio seja liberado. Por padrão, as transações SQL Server não têm
tempo limite, a menos que LOCK_TIMEOUT seja configurado. A transação solicitante é
bloqueada, não em deadlock, por que ela não fez nada para bloquear a transação que
deve o bloqueio. Finalmente, a transação proprietária vai terminar e liberar o bloqueio e a
transação solicitante terá o bloqueio atribuído e processado.
Os deadlocks às vezes são chamados de abraço mortal.
Deadlock é uma condição que pode ocorrer em qualquer sistema com vários threads, não
só em sistemas de gerenciamento de banco de dados relacional, e pode ocorrer para
outros recursos, além de bloqueios de objetos em bancos de dados. Por exemplo, um
thread em um sistema operacional de vários threads pode adquirir um ou mais recursos,
como bloqueios de memória. Se o recurso sendo adquirido é atualmente propriedade de
outro thread, o primeiro thread pode ter que esperar o thread proprietário liberar o recurso
alvo. O thread em espera tem uma dependência do thread proprietário para aquele
recurso em particular. Em uma instância do Mecanismo de Banco de Dados, sessões
podem fazer um deadlock ao adquirir recursos que não são de banco de dados, como
memória ou threads.

Na ilustração, a transação T1 tem uma dependência da transação T2 para o recurso de

bloqueio de tabela Part. Da mesma forma, a transação T2 tem uma dependência da
transação T1 para o recurso de bloqueio de tabela Supplier. Devido a essas
dependências formarem um ciclo, há um deadlock entre as transações T1 e T2.
Os deadlocks também podem ocorrer quando uma tabela é particionada e a configuração
LOCK_ESCALATION do ALTER TABLE é configurada para AUTO. Quando a
LOCK_ESCALATION é configurada para AUTO, a simultaneidade aumenta ao permitir
que o Mecanismo de Banco de Dados bloqueie partições de tabela no nível de HoBT em
vez de no nível de TABLE. Entretanto, quando transações separadas mantêm bloqueios
de partição em uma tabela e querem um bloqueio em algum lugar de outra partição de
transações, isso causa um deadlock. Esse tipo de deadlock pode ser evitado
configurando LOCK_ESCALATION para TABLE; embora essa configuração irá reduzir a
simultaneidade forçando as atualizações extensas em uma partição a esperarem por um
bloqueio de tabela.

Exemplo de como tratar deadlock:

TentaNovamente:
SET @NumTentativas += 1 -- incrementa o contador

BEGIN TRY
BEGIN TRANSACTION
UPDATE Production.Product SET ListPrice = 09.99 WHERE ProductID = 1
UPDATE Production.Product SET ListPrice = 04.99 WHERE ProductID = 2
COMMIT TRANSACTION
END TRY

BEGIN CATCH
SET @Err = @@ERROR
IF @Err = 1205 -- um deadlock foi detectado
BEGIN
ROLLBACK TRANSACTION
WAITFOR DELAY '00:00:05'
PRINT 'Aconteceu um deadlock!, tentativa ' + CAST(@NumTentativas AS CHAR(1)) -- insira
aqui o que você quer fazer para avisar ao usuario sobre a nova tentativa, etc.
IF @NumTentativas < @MaxPermitido -- testa quantas vezes tentaremos de novo
GOTO TentaNovamente; -- tenta executar o update novamente
END
END CATCH

Packges

Funções do SQL
Exemplo Count()

Split

Tuning