FUNCTION - STORED PROCEDURES

Function (Stored Procedure)

Stored Procedures são nada mais que programas desenvolvidos em determinada linguagem de script e armazenados no servidor, local onde serão processados. Eles também são conhecidos como funções, este é o motivo pelo qual quando nos referenciamos a uma stored procedure no PostgreSQL devemos utilizar o nome de Function.
O PostgreSQL conta com três formas diferentes de criar funções:
- Funções em Linguagem SQL: São funções que utilizam a sintaxe SQL e se caracterizam por não possuírem estruturas de condição (if, else, case), estruturas de repetição (while, do while, for), não permitirem a criação de variáveis e utilizam sempre alguns dos seguintes comandos SQL: SELECT, INSERT, DELETE ou UPDATE.
- Funções de Linguagens Procedurais: ao contrário das funções SQL, aqui é permitido o uso de estruturas de condição e repetição e o uso de variáveis. As funções em linguagens procedurais caracterizam-se também por não possuírem apenas uma possibilidade de linguagem, mas várias. Normalmente a mais utilizada é conhecida como PL/PgSQL, linguagem fortemente semelhante ao conhecido PL/SQL utilizado no Oracle.
- Funções em Liguagens Externas ou de Rotinas Complexas: São funções normalmente escritas em C++ que trazem consigo a vantagem de utilizarem uma linguagem com diversos recursos, na qual pode-se implementar algoritmos com grande complexidade. Tais funções são empacotadas e registradas no SGBD para seu uso futuro.
Para criar uma função utilizando SQL no PostgreSQL utiiza-se o comando CREATE FUNCTION, da seguinte forma:
CREATE [ OR REPLACE ] FUNCTION nome ( [ tipo_do_parametro1 [, ...] ] )
RETURNS tipo_retornado AS '
Implementação_da_função;
'
LANGUAGE 'SQL';
Na qual CREATE FUNCTION é o comando que define a criação de uma função, [OR REPLACE] informa que se acaso existir uma função com este nome, a atual função deverá sobrescrever a antiga. RETURNS tipo_retornado informa o tipo de dado que será retornado ao término da função. Tais tipos de retornos são os convencionais como o INTEGER, FLOAT, VARCHAR, etc. As funções em SQL também permitem o retorno de múltiplos valores e para isso informa-se como retorno SETOF. Implementação_da_função, como o nome mesmo diz, traz as linhas de programação para a implementação da stored procedure. LANGUAGE está avisando qual linguagem em que está sendo implementada a função.
Quando passamos parâmetros à função, não utilizamos nome nas variáveis que estão dentro dos parênteses da assinatura da função. Utilizamos apenas separados por vírgulas, o tipo da variável de parâmetro. Para acessarmos o valor de tais parâmetros, devemos utilizar o '$' mais o número da posição que ocupa nos parâmetros, seguindo a ordem da esquerda para a direita:
CREATE FUNCTION soma(INTEGER, INTEGER)
RETURNS INTEGER AS
'
SELECT $1 + $2;
'
LANGUAGE 'SQL';
Outro detalhe importante é o fato de que as funções utilizando SQL sempre retornam valor, o que faz com que seja sempre necessário que a última linha de comando da função utilize o comando SELECT.
CREATE FUNCTION cubo(INTEGER)
RETURNS FLOAT AS
'
SELECT $1 ^ 3;
'
LANGUAGE 'SQL';
Quando desejar excluir uma função do sistema utilize o comando:
DROP FUNCTION nome_da_funcao();
Para excluir uma função é necessário passar toda a sua assinatura:
DROP FUNCTION nome_da_funcao(INTEGER);
Ainda existe o fato que no momento da exclusão você pode excluir a função passando mais um parâmetro, como no exemplo a seguir:
DROP FUNCTION totalNota(INTEGER) RESTRICT;
ou
DROP FUNCTION totalNota(INTEGER) CASCADE;
Passando o RESTRICT como parâmetro, a exclusão da função será recusada caso existam dependências de objetos em torno da função (como por exemplo, triggers e operadores). Com o CASCADE esses objetos serão excluídos juntamente com a função.
Outro detalhe importante a ser destacado sobre o artigo anterior é a maneira como utilizamos as funções. Quando a função é criada sem o uso de retorno SETOF, basta utilizarmos a seguinte sintaxe:
SELECT nome_da_funcao();
O mesmo modo deve ser usado quando as funções são criadas utilizando SETOF com tipos já definidos pelo PostgreSQL, como por exemplo, INTEGER, TIMESTAMP ou outro. Mas quando as funções possuem o seu retorno referenciado em uma tabela ou uma view, ou seja, quando a função retorna um resultset, devemos utilizar a função da seguinte maneira:
SELECT * FROM nome_da_funcao();
Quando criamos uma função tanto em SQL como em PL/PgSQL e posteriormente necessitamos alterar a sua seqüência de instruções, basta utilizarmos o comando CREATE OR REPLACE, desde que a alteração da função não altere o tipo de retorno. Se isto ocorrer, a função terá que ser excluída primeiro para depois ser adicionada à nova versão.
Se a função for removida e recriada, a nova função não é mais a mesma entidade que era antes; ficarão inválidas as regras, visões, gatilhos, etc. existentes que fazem referência à antiga função. Use o comando CREATE OR REPLACE FUNCTION para mudar a definição de uma função, sem invalidar os objetos que fazem referência à função.
O PostgreSQL, lembrando o que acontece com linguagens como Java, permite a sobrecarga de funções, ou seja, o mesmo nome pode ser utilizado em funções diferentes, desde que os argumentos sejam de tipos distintos, portanto há possibilidade de que existam duas funções soma, uma retornando a soma de valores do tipo integer e outra do tipo float.





Alguns exemplos

CREATE TABLE genero
( id numeric(5) NOT NULL,
nome varchar(100),
CONSTRAINT genero_pkey PRIMARY KEY (id)
);

CREATE TABLE filme
(
id numeric(5) Primary key,
nome varchar(100),
duracao varchar(100),
sinopse varchar(2000),
genero numeric(5),
data timestamp,
CONSTRAINT fk_genero_filme FOREIGN KEY (genero) REFERENCES genero (id) ON UPDATE NO ACTION ON DELETE NO ACTION
);

insert into genero values(1,'Drama');
insert into genero values(2,'Comédia');
insert into genero values(3,'Terror');
insert into genero values(4,'Suspense');
insert into genero values(5,'Romance');

insert into filme values(1,'Os outros','90 min','aaaaaaaaaaaaaaa',4,'2006/08/15');
insert into filme values(2,'Duplex','90 min','aaaaaaaaaaaaaaa',2,'2006/01/21');
insert into filme values(3,'Clik','120 min','aaaaaaaaaaaaaaa',2,'2006/09/20');
insert into filme values(4,'O Piano','90 min','aaaaaaaaaaaaaaa',1,'2006/08/15');
insert into filme values(5,'O Diário da Princesa','120 min','aaaaaaaaaaaaa',5,'2006/05/14');
insert into filme values(6,'Jogos Mortais','120 min','aaaaaaaaaaaaaaa',3,'2005/08/15');
insert into filme values(7,'Pânico','90 min','aaaaaaaaaaaaaaa',3,'2006/08/15');

CREATE FUNCTION duracao_filme(INTEGER)
RETURNS VARCHAR AS 'SELECT duracao FROM filme WHERE id = $1;'
LANGUAGE 'SQL';
select duracao_filme(1);

CREATE FUNCTION filmes_genero(integer)
RETURNS SETOF varchar AS 'SELECT nome FROM filme WHERE genero = $1;'
LANGUAGE 'SQL';
select filmes_genero(1);

drop function soma1(integer, integer);

CREATE OR REPLACE FUNCTION primeira_funcao()
RETURNS VOID AS
$body$
BEGIN
RAISE NOTICE 'Minha primeira rotina em PL/pgSQL';
RETURN;
END;
$body$
LANGUAGE 'plpgsql';
select primeira_funcao();

CREATE OR REPLACE FUNCTION primeira_funcao(integer,integer)
RETURNS integer AS
$body$
declare soma integer;
BEGIN
RAISE NOTICE 'Minha primeira rotina em PL/pgSQL';
soma:=$1+$2;
RETURN(soma);
END;
$body$
LANGUAGE 'plpgsql';
select * from primeira_funcao(5,1);

CREATE OR REPLACE FUNCTION primeira_funcao(integer, integer)
RETURNS integer AS
$body$
declare soma integer;
BEGIN
RAISE NOTICE 'Minha primeira rotina em PL/pgSQL';
if $1 > $2 then
soma:=$1-$2;
else
soma:=$2-$1;
end if;
RETURN(soma);
END;
$body$
LANGUAGE 'plpgsql';
select * from primeira_funcao(5,1);

CREATE OR REPLACE FUNCTION primeira_funcao(n1 integer,n2 integer)
RETURNS integer AS
$body$
declare soma integer;
BEGIN
RAISE NOTICE 'Minha primeira rotina em PL/pgSQL';
if n1 > n2 then
soma:=n1-n2;
else
soma:=n2-n1;
end if;
RETURN(soma);
END;
$body$
LANGUAGE 'plpgsql';
select * from primeira_funcao(5,1);

Comentários

Postagens mais visitadas deste blog

ORIGEM DA HOMILÉTICA E DA RETÓRICA

EXEMPLOS DE REQUISITOS NÃO FUNCIONAIS

1 e 2 SAMUEL