Utilizando Stored Procedure (SP) no Firebird

O uso de Stored Procedures é muito útil em um ambiente cliente/servidor em função de fatores como desempenho, redução do tráfego de informações pela rede, agilidade e segurança. Neste artigo vamos explorar o poder das SPs, inicialmente definirei Stored Procedure, os tipos suportados pelo Firebird, sua estrutura e por fim criaremos uma SP e analisaremos a mesma linha a linha.

Stored Procedure (SP) é, na sua essência, um programa PSQL, que é armazenada em um banco de dados Firebird. A stored procedure é composta pelos comandos SQL, variáveis¹ e comandos de fluxo lógico. As SPs podem receber (caso existam) e retornar (caso a SP retorne valores) valores através de parâmetros de entrada e saída.

O Firebird suporta dois tipos de SPs: executáveis que retornam no máximo um registro e as selecionáveis que podem retornar vários registros. As SPs selecionáveis se comportam como “tabelas virtuais - views“ do banco, já que podem ser utilizadas como fonte de dados em selects. As SPs selecionáveis são um extraordinário recurso nos fornecido pelo Firebird e que eu em particular uso e abuso das mesmas para me auxiliar na confecção de relatórios.

As SPs são executas em um determinado momento, através de chamadas de execução específica, acionada pelo desenvolvedor ou pela aplicação no momento desejado.

Estrutura e criação de uma SP – O comando para criação de uma SP é o Create Procedure. Uma SP tem duas partes: cabeçalho e corpo. No cabeçalho, temos a definição do nome da SP, parâmetros de entrada (caso existam) e parâmetros de saída (caso a SP retorne valores). O corpo contém declarações de variáveis e comandos a serem executados.

Create Procedure Minha_Primeira_SP (

Param1 tipo, --- lista de parâmetros de entrada -----

Param2 tipo)

Returns (

Valor1 tipo, --- lista de valores de saída -----

Valor2 tipo)

As

Declare variable var1 tipo; ---- lista de variáveis -----

Declare variable var2 tipo;

Begin

(Corpo da SP – comandos)

End

Vamos agora ver na prática a criação de uma SP que funciona como um gerador de códigos para tabelas – (tipo um generetor);

1 CREATE PROCEDURE NOVO_CODIGO (

2 tabela varchar(30))

3 returns (

4 proximo_codigo integer)

5 as

6 declare variable codigo_atual integer;

7 begin

8 --Recupera o valor atual do código

9 select id_atual from controle_id c

10 where (c.tabela = :tabela)

11 into :codigo_atual;

12 --Verifica se o valor do código é nulo

13 if (:codigo_atual is null) then

14 begin

15 proximo_codigo = 1;

16 insert into controle_id (tabela, id_atual)

17 values (:tabela, :proximo_codigo);

18 end

19 else

20 begin

21 proximo_codigo = codigo_atual + 1;

22 update controle_id set id_atual = :proximo_codigo

23 where (tabela = :tabela);

24 end

25 suspend;

26 end

Agora vamos analisar nossa SP, linha a linha.

Linha 1 – Criamos a SP com o nome Novo_Codigo, bastante sugestivo -:) para a finalidade da mesma;

Linha 2 – Definimos o parâmetro de entrada com seu respectivo tipo, que deverá ser informado para sua execução;

Linha 3 – Returns( ) – define que os valores ali contidos serão retornados pela SP;

Linha 4 – A variável com o seu respectivo tipo, que será o nosso valor de retorno;

Linha 6 – Declaração de uma variável com seu respectivo tipo que será utilizada no processamento da SP;

Linhas 7 e 26 – Begin/End (bastante conhecidos nosso -:) - um bloco que limita uma seqüência de comandos e instruções) - define o inicio e fim de nossa SP;

Linhas 8 e 12 – Comentários;

Linhas 9 a 11 – Fazemos uso de um select para recuperarmos da tabela que será passada por parâmetro para SP o valor do campo id_atual da tabela controle_id e inserimos o valor retornado na variável codigo_atual;

Linhas 13 a 24 – Verificamos se o valor retornado é nulo e caso verdadeiro atribuímos a nossa variável de retorno (proximo_codigo) o valor 1 e inserimos um novo registro na tabela Controle_Id senão atribuímos a nossa variável de retorno (proximo_codigo) o valor do código_atual + 1 e atualizamos o registro da tabela Controle_Id;

Linha 25 – Instrução SUSPEND, suspenderá a execução da procedure e retornará o valor de saída.

Bem amigos, neste artigo tivemos uma breve introdução a este extraordinário recurso que o Firebird nos disponibiliza as Stored Procedures, porém ainda temos muito, mais muito mesmo o que explorar. Num próximo artigo demonstrarei um pouco mais do que podemos fazer utilizando SP, onde iremos usar um loop para podermos resgatar n-registros, tratar valores enfim... usar um pouco mais do poder das SPs.

Referências:

1. Cantu, Carlos Henrique, Firebird Essencial, Rio de Janeiro, Ed. Ciência Moderna, 2005, 308p.
2. Cantu, Carlos Henrique, Firebird 2.0 – O Banco de Dados do Novo Milênio, Ed. Ciência Moderna, 2006, 304p.

1 - Os tipos dessas variáveis podem ser qualquer tipo nativo suportado pelo Firebird, exceto array e blob.