Pacote para Concursos de Ti Cursos Regulares Sgbds para Concursos Curso Regular Aula 03

Aula 03
SGBDs para Concursos - Curso Regular

Professor: Thiago Rodrigues Cavalcanti
PostgreSQL PL/pgSQL
Prof. Thiago Cavalcanti
AULA 03: PL/pgSQL
Sumário
PL/pgSQL........................................................................................................................................................ 1
1. Introdução ..................................................................................................................................... 1
1.1. Por que você deve usar PL/pgSQL? ............................................................................. 2
1.2. Instalando PL/pgSQL ......................................................................................................... 2
2. Entendendo a estrutura do PL/pgSQL ................................................................................ 3
2.1. Usando Variáveis ..................................................................................................................... 4
2.2. Trabalhando com erros e exceções - RAISE ................................................................ 6
2.3. Chamadas e retornos de função ....................................................................................... 8
2.4. Estruturas de controle........................................................................................................... 9
2.4.1. Comandos condicionais .................................................................................................. 10
2.4.2. LOOPS ................................................................................................................................... 13
2.5. STORED PROCEDURES ....................................................................................................... 14
2.6. FUNCTIONS ............................................................................................................................. 14
2.7. TRIGGERS ................................................................................................................................ 16
Questões Comentadas ............................................................................................................................ 18
Questões PostgreSQL - CESPE ........................................................................................................ 26
Gabarito .................................................................................................................................................... 34
Considerações finais ................................................................................................................................ 35
Referências .................................................................................................................................................. 35
Essa aula tem por objetivo apresentar a versatilidade das linguagens

procedurais que podem ser utilizadas com o postgreSQL, especialmente o PL/pgSQL.
Veremos como a escrever programas utilizando as extensões procedurais da
linguagem SQL.
PL/pgSQL
1. Introdução 16712855225
Vamos imaginar duas situações distintas. Na primeira você executa comandos

SQL várias vezes a partir de um cliente, o que exige um excessivo tráfego de rede,
que piora com a distância entre o servidor de banco de dados e o cliente. Na segunda
o cliente executa blocos de código armazenados em um servidor de banco de dados
que tem o mesmo propósito do código anterior evitando o tráfego entre o cliente e o
servidor.
Entre as duas alternativas acima, qual delas você iria escolher? Parece óbvio
que a segunda opção seria a melhor alternativa? Esse bloco de código é conhecido
como linguagem procedural. Mais especificamente, no caso do postegres, essa
linguagem é denominada Procedural Language/PostegreSQL ou PL/pgSQL.
PL/pgSQL está para o PostgreSQL, assim como o PL/SQL está para o Oracle (ou
Transact/SQL está para o Microsoft SQL Server). Linguagens procedurais podem ser
Prof. Victor Dalton www.estrategiaconcursos.com.br 1 de 35
PostgreSQL PL/pgSQL
utilizadas para escrevermos funções. No caso de PL/pgSQL, as funções são uma

sequência de comandos SQL nomeadas. Ao fazer isso, você está estendendo o
servidor. Estas extensões do servidor também são conhecidas como procedimentos
armazenados (stored procedures). Vamos, então, tratar um pouco mais sobre essas
características das linguagens procedurais.
Antes de continuarmos nosso estudo vale uma observação. Do ponto de vista
de sintaxe ou comandos de criação de estruturas para procedimentos armazenados, o
PL/pgSQL não oferece a possiblidade de definirmos objetos do tipo stored procedure.
Os procedimentos armazenados podem ser apenas do tipo function. Falaremos sobre
as functions mais a frente. Por enquanto, o que eu quero que você tenha em mente é
que não podemos criar uma stored procedure como fazemos no PL/SQL. Ok?! Espero
que sim! 
1.1. Por que você deve usar PL/pgSQL?
As instruções SQL são executadas individualmente, sendo assim suas consultas

são enviadas uma por uma para o servidor a fim de serem analisadas, processadas e
devolvidas como o resultado. Fazer isso, ocasionalmente, não é um problema,
contudo, quando você tem que executar milhares de consultas semelhantes por dia,
você pode simplesmente escrever uma função PL/pgSQL. Mais especificamente, é
possível escrever um procedimento armazenado que pode executar todas as
instruções SQL usando qualquer uma das estruturas de controle disponíveis.
Existem alguns tipos de estruturas de controle que aparecem dentro de um
código PL/pgSQL. Estruturas de controle de loop, como WHILE e FOR, serão
executadas após uma decisão tomada por estruturas condicionais (CASE e IF),
utilizadas juntamente com as variáveis que são declaradas para armazenar os
resultados e, até mesmo, processar estes resultados mais tarde. Além disso, é
possível lidar com erros e exceções. PL/pgSQL encapsula comandos de SQL e
implementa conceitos de programação semelhante a outras línguas.
Você pode escrever essas funções em uma variedade de idiomas disponíveis,
por exemplo, podemos usar Perl, Python, Java, e assim por diante. Funções escritas
16712855225
em PL/pgSQL podem chamar outras funções ou conter sub-blocos dentro do bloco de

código principal.
Com estas características de extensibilidade, não precisa ser mencionado que o
desempenho certamente será melhorado. Vamos então aprender a usar essa
ferramenta, primeiramente aprendendo a instalar o serviço dentro do servidor.
1.2. Instalando PL/pgSQL
Você deve se certificar de ter instalado a linguagem procedural que você está
prestes a usar. O PostgreSQL suporta várias linguagens, como vimos anteriormente, e
garante que o processo de instalação seja bastante simples e transparente.
Você pode consultar o manual online do PostgreSQL presente em
www.postgresql.org/docs/9.5/static/index.html para conhecer a sintaxe geral dos

PostgreSQL PL/pgSQL
comandos, declarações, funções e assim por diante. Na verdade, a documentação

servirá como uma fonte para um estudo detalhado dos recursos do PostgreSQL, não
somente da PL/pgSQL.
Para iniciar o utilitário de linha de comando basta executar o seguinte
comando:
$ createlang plpgsql database-name
O PL/pgSQL é instalado por padrão, sendo assim ao executar o comando
anterior você poderá receber uma mensagem dizendo que a linguagem já está
instalada.
Suponha que temos que instalar o recurso de PL/pgSQL no banco de dados
concurso_db. Então, você vai executar o seguinte comando (shell Linux é usado
neste exemplo):
$ createlang plpgsql concurso_db
O comando anterior assume que o usuário do sistema operacional é o mesmo
que o superusuário do banco de dados. Se este não for o caso, devemos passar o
nome do superusuário usando o comando ‘-U’ como se segue:
$ createlang plpgsql concurso_db -U postgres
Você não precisa inserir um ponto e vírgula no final, pois esse não é um
comando SQL, mas sim uma invocação através do utilitário de linha de comando para
o script shell createlang que carrega a linguagem processual no banco de dados.
Agora que temos certeza que nosso SGBD vai aceitar os comandos PL/pgSQL,
vamos seguir em frente para aprender um pouco da sintaxe da linguagem.
2. Entendendo a estrutura do PL/pgSQL

Nesta parte da aula vamos falar das principais características sintáticas do
PL/pgSQL, linguagem procedural carregável para o sistema de banco de dados
PostgreSQL. Os objetivos de projeto da PL/pgSQL foram de criar uma linguagem
16712855225
procedural que (1) possa ser usada para criar funções e procedimentos de gatilhos,
(2) acrescente estruturas de controle à linguagem SQL, (3) possa realizar cálculos
complexos, (4) herde todos os tipos, funções e operadores definidos pelo usuário, (5)
possa ser definida como confiável pelo servidor, e (6) seja fácil de usar.
Funções criadas com PL/pgSQL podem ser usadas em qualquer lugar que uma
das funções internas do postgres possam aparecer. Por exemplo, é possível criar
funções de cálculo condicional complexo e depois usá-las para definir operadores ou
utilizá-las em expressões de índice.
No PostgreSQL 9.0 e versões posteriores, a PL/pgSQL é instalada por padrão.
No entanto, ainda é um módulo carregável, especialmente para que os
administradores de segurança possam optar por removê-lo conscientemente.
PL/pgSQL é uma linguagem estruturada em blocos. O contexto completo usado
para a definição de uma função deve ser um bloco. Um bloco é definido como:
PostgreSQL PL/pgSQL
Cada declaração (declaration) e cada instrução (statement) dentro de um bloco

são encerradas por um ponto e vírgula. Um bloco que aparece dentro de outro bloco
deve ter um ponto e vírgula depois da cláusula END, como mostrado acima. No
entanto, o END final que conclui um corpo de função não necessita de um ponto e
vírgula.
A label só é necessária se você deseja identificar o bloco para uso em uma
declaração de EXIT, ou para qualificar os nomes das variáveis declaradas no bloco. Se
um rótulo ou label é dado após o END, este deve corresponder ao mesmo nome
declarado no início do bloco.
Todas as palavras-chave são case-insensitive. Os identificadores são
convertidos implicitamente em minúsculas ao menos que eles sejam definidos entre
aspas, esse comportamento também acontece em comandos SQL comuns.
Comentários funcionam da mesma maneira no código PL/pgSQL e no SQL
comum. Um traço duplo (--) inicia um comentário que se estende até a extremidade
da linha. A notação “/*” começa um bloco de comentário que se estende até
encontrar a ocorrência de “*/”. Essa segunda opção é utilizada para comentários em
múltiplas linhas.
2.1. Usando Variáveis

Qualquer declaração na seção declarations de um bloco pode ser um sub-bloco.
Sub-blocos podem ser usados para agrupamento lógico ou para localizar variáveis
associadas a um grupo menor de declarações. Variáveis declaradas em um sub-bloco
vão mascarar quaisquer variáveis com mesmo nome de blocos externos durante a
16712855225
execução do sub-bloco. Você pode acessar as variáveis externas se você qualifica seus
nomes com a etiqueta do seu bloco. Vejam o exemplo de comando abaixo para
entender melhor a sintaxe na prática:

PostgreSQL PL/pgSQL
Observem a presença de um sub-bloco e a utilização da variável quantity. Seu

valor vai depender da posição em que é chamada dentro da função. Observem ainda a
utilização do nome do bloco externo <<outerblock>> para referenciar o valor da
variável quantity presente no bloco.
Vamos agora aprender como declaramos variáveis dentro de um bloco e quais
são os elementos sintáticos utilizados. Vejam a sintaxe para declaração de variável e
atribuição de valor.
name [ CONSTANT ] type [ COLLATE collation_name ] [ NOT NULL ] [ {

DEFAULT | := | = } expression ];
A cláusula DEFAULT, caso exista, especifica o valor inicial atribuído à variável

quando o bloco é inserido. Se a cláusula DEFAULT não for fornecida, então a variável
é inicializada com o valor NULL. A opção CONSTANT evita que seja atribuído a variável
16712855225
outro valor após a inicialização, a fim de que o seu valor se mantenha constante
durante a execução do bloco.
A opção COLLATE especifica um agrupamento de caractere relacionado à
linguagem utilizada para a variável. Se NOT NULL for especificado, uma atribuição de
valor nulo resulta em um erro em tempo de execução. Todas as variáveis declaradas
como NOT NULL devem ter um valor padrão não nulo especificado. Existe a opção de
usar o sinal de igual (=) para atribuição de valor a variável, ele é usado em vez do
padrão PL/SQL que é o := (dois pontos igual).

PostgreSQL PL/pgSQL
01. BANCA: VUNESP ANO: 2013 ÓRGÃO: COREN-SP PROVA: ANALISTA -

SISTEMAS
Na linguagem PL/pgSQL, o comando para declarar uma constante, de nome ‘mouse’,

com valor inteiro igual a 3 é
A pg_CONST mouse :=3;
B pg_CONST mouse, INTEGER 3;
C pg mouse CONST, DEFAULT := 3;
D mouse DEFAULT := 3;
E mouse CONSTANT INTEGER := 3;
Gabarito E. Essa questão trata dos conceitos que acabamos de falar. Vejam que a
sintaxe correta para a variável mouse deve ser seguida pela palavra reservada
CONSTANT, indicando uma constante. Logo após devemos definir o tipo da variável,
neste caso INTEGER e atribuir seu valor inicial três. Para finalizar basta colocar o
ponto e vírgula indicando termino do comando de declaração. Observamos essa
descrição na alternativa E.
Resumindo, as variáveis são usadas no código PL/pgSQL para armazenar dados

modificáveis de um tipo explicitamente indicado. Todas as variáveis que você vai usar
dentro de um bloco de código devem ser declaradas sob a palavra-chave DECLARE.
Se uma variável não é inicializada com um valor padrão no momento da sua
declaração, o seu valor será o padrão para o tipo SQL NULL. E quais os outros tipos
que podem ser definidos para uma variável?
Variáveis em PL/pgSQL podem ser representadas por qualquer um dos tipos de
dados padrão SQL, como um inteiro ou caractere. Além dos tipos de dados SQL,
PL/pgSQL também fornece o tipo de dados adicional RECORD, que é projetado para
permitir que você armazene informações da uma linha sem especificar as colunas que
serão fornecidos quando os dados são armazenados na variável. Veremos mais
informações sobre o uso deste tipo de dados posteriormente. A lista a seguir traz os
16712855225
tipos de dados mais comumente usados em PL/pgSQL: boolean, text, char, integer,
double precision, date e time.
2.2. Trabalhando com erros e exceções -

RAISE
Outra característica é podermos utilizar a instrução RAISE para relatar
mensagens e exibir erros. A instrução RAISE envia informações específicas aos
mecanismos utilitários do PostgreSQL, ereport ou elog. Esses utilitários de log de
erro normalmente registram as informações no diretório /var/log/messages, em
$PGDATA/severlog, ou definindo a utilização do stderr.

PostgreSQL PL/pgSQL
A instrução RAISE também é descreve o nível de erro que trata do grau de

severidade do problema encontrado, e a mensagem que deve ser enviada pelo
PostgreSQL ao usuário. Além disso, você pode listar as variáveis e as expressões
cujos valores você deseja colocar na mensagem de erro. Use o sinal de porcentagem
(%) para marcar os locais na cadeia de caracteres no qual esses valores devem ser
inseridos. Veja as possibilidades de uso do comando na figura abaixo:
A opção level especifica a gravidade do erro. Os níveis permitidos são DEBUG,

LOG, INFO, NOTICE, WARNING e EXCEPTION, com EXCEPTION sendo o padrão.
EXCEPTION gera um erro que normalmente aborta a transação corrente. Os outros
níveis apenas geram mensagens de diferentes níveis de prioridade. Se as mensagens
de um nível prioridade são informadas ao cliente, escritas no log do servidor, ou
ambos, esse processo é controlado pelas variáveis de configuração log_min_messages
e client_min_messages.
Após de definir o level, você pode escrever um format (que deve ser uma
string literal simples, não uma expressão). O formato da string especifica o texto da
mensagem de erro a ser relatado. O formato da cadeia de caracteres pode ser
seguido por expressões com argumentos opcionais a serem inseridos na mensagem.
Dentro da string, o símbolo de ‘%’ passa a ter a representação de uma cadeia cujo
valor será estabelecido pelo próximo argumento opcional. Veja no exemplo abaixo a
substituição na prática:
Você pode anexar informações adicionais ao relatório de erro por escrito,

utilizando a sintaxe “opção = expressão”. Cada expressão pode ser qualquer
16712855225
expressão cujo valor seja representado por uma string. As palavras-chave permitidas
para opção são:
MESSAGE - Define o texto da mensagem de erro. Esta opção não pode ser
usada quando o RAISE incluir uma string formatada antes do USING. Observe as
descrições do comando RAISE acima.
DETAIL- Fornece uma mensagem de detalhe erro.
HINT - Fornece uma mensagem com uma dica para a resolução do problema.
ERRCODE - Especifica o código de erro (SQLSTATE) reportado.
Vejam mais um exemplo abaixo onde apresentamos uma forma de utilização do

comando RAISE com a cláusula USING e a opção HINT.

PostgreSQL PL/pgSQL
2.3. Chamadas e retornos de função

A sintaxe normal para chamar uma função PL/pgSQL é simples. Basicamente,
podemos fazer de duas formas, primeiro utilizando uma referência à função em uma
instrução SQL SELECT, ou durante a atribuição de uma variável. Por exemplo:
SELECT function_identifier (arguments);

variable_identifier := function_identifier (arguments);
O uso de atribuições e instruções de SELECT para executar funções é o padrão

em PL/pgSQL porque todas as funções em um banco de dados PostgreSQL devem
retornar um valor de algum tipo. Contudo, você pode utilizar a palavra-chave PEFORM
para chamar uma função e ignorar os seus dados de retorno. O exemplo a seguir
mostra a sintaxe da chamada de função usando a palavra-chave PEFORM.
PERFORM function_identifier(arguments);
Existem, ainda, dois comandos disponíveis que permitem ao usuário retornar

dados de uma função: RETURN e RETURN NEXT. O RETURN, seguido de uma
expressão, termina a execução da função e retorna o valor da expressão. Este
comando é utilizado para funções PL/pgSQL que não retornam um conjunto de linhas.
RETURN NEXT e RETURN QUERY não trazem exatamente o retorno de uma função.
Eles simplesmente acrescentam zero ou mais linhas no conjunto que contem o
resultado da função.
Aqui está um exemplo de uma função usando RETURN NEXT:
16712855225

PostgreSQL PL/pgSQL
Vejamos agora algumas informações a respeito das estruturas de controle e

sobre as definições de procedimentos de TRIGGERS com PL/pgSQL. Observem que
PL/pgSQL parte da estrutura DECLARE, BEGIN e END definida anteriormente.
2.4. Estruturas de controle

A maioria das linguagens de programação existentes fornecem maneiras de
controlar o fluxo dos programas criados por ela. PL/pgSQL não é diferente.
Tecnicamente, definindo a estrutura dos comandos dentro de uma função PL/pgSQL
você está controlando o seu "fluxo", sendo assim, você está controlando a maneira
pela qual ela opera e a ordem na qual suas operações são executadas. No entanto,
existem diversas formas pelas quais você pode controlar o fluxo de um código
PL/pgSQL, tais como instruções condicionais e o uso de loops.
16712855225
As estruturas de controle são, provavelmente, a parte mais útil (e importante)

da PL/pgSQL. Com estruturas de controle, você pode manipular os dados de forma
muito flexível e poderosa.
As declarações IF e CASE permitem que você execute comandos

alternativamente com base em certas condições. PL/pgSQL possui três formas para a
construção de estruturas com o IF e duas formas para o CASE:
 IF ... THEN
 IF ... THEN ... ELSE
 IF ... THEN ... ELSIF ... THEN ... ELSE
 CASE ... WHEN ... THEN ... ELSE ... END CASE

PostgreSQL PL/pgSQL
 CASE WHEN ... THEN ... ELSE ... END CASE
Vamos agora detalhar um pouco mais cada um desses comandos verificando

alguns exemplos para cada um deles.
2.4.1. Comandos condicionais

A instrução IF/THEN permite que você especifique uma declaração ou bloco de
instruções que deve ser executado se uma determinada condição for avaliada como
verdadeira. A sintaxe da instrução IF/THEN é mostrada no abaixo.
CREATE FUNCTION identifier (arguments) RETURNS type AS '

DECLARE
declarations
BEGIN
IF condition THEN
statement;
[...]
END IF;
END;
' LANGUAGE 'plpgsql';
Vamos começar a observar códigos um pouco mais complexos. No exemplo a

seguir, uma função é criada para verificar o estoque de um livro quando o ID do livro
e o número da edição são informados. O ID do livro é um número gravado e
rastreado, listado internamente em algumas das tabelas da base de dados. Assim,
esta função é projetada para ser usada por outras funções, baseada no fato que a
maioria dos usuários não sabe diretamente o número ID do livro. A função quantidade
em estoque primeiro recupera o número ISBN do livro com uma instrução SELECT
INTO.
Se a instrução SELECT INTO não pôde recuperar um número ISBN para o livro
baseada no ID do mesmo e no número da edição fornecida à função de quantidade, a
16712855225
ação retorna um valor de -1, que deve ser interpretado como um erro pela função que
o chamou. O fluxo da função continua se houver um número de ISBN encontrado para
o livro, então outro SELECT INTO é usado para recuperar a quantidade remanescente
em estoque para o livro em questão. A quantidade é, em seguida, retornada e a
função termina. Vejamos seu código:
CREATE FUNCTION stock_amount (integer, integer) RETURNS integer AS '

DECLARE
b_id ALIAS FOR $1;

b_edition ALIAS FOR $2;
b_isbn text;
stock_amount integer;

PostgreSQL PL/pgSQL
BEGIN
SELECT INTO b_isbn isbn FROM editions WHERE

book_id= b_id AND edition = b_edition;
IF b_isbn IS NULL THEN

RETURN -1;
END IF;
SELECT INTO stock_amount stock FROM stock WHERE isbn = b_isbn;
RETURN stock_amount;
END;
A instrução IF/THEN/ELSE permite que você especifique um bloco de instruções

que devem ser executados se uma condição avaliada como verdadeira, e também um
bloco de instruções que devem ser executadas se a condição for avaliada como falsa.
A sintaxe do IF/THEN/ELSE é mostrada abaixo:

DECLARE
declarations
BEGIN
IF condition THEN
statement;
[...]
ELSE
statement;
[...]
END IF; 16712855225
END;
A sequência condicional IF/THEN/ELSE/IF é um mecanismo para ligar várias

instruções IF juntas em série. Em primeiro lugar, uma condição é verificada. Se a
primeira condição for avaliada como FALSE, outra condição é verificada, e assim por
diante. A cláusula final ELSE deve prever o caso quando nenhuma condição for
avaliada como TRUE. A sintaxe para a declaração IF/THEN/ELSE/IF é a seguinte:

DECLARE
declarations
BEGIN
IF condition THEN

PostgreSQL PL/pgSQL
statement;
[...]
ELSE IF condition
statement;
[...]
END IF;
END;
Vamos agora falar um pouco sobre os comandos CASE:
A instrução CASE simples ajuda na execução de condições quando existe uma

igualdade entre os operandos. A expressão de pesquisa é avaliada e, em seguida,
combinada com cada expressão na cláusula WHEN. Quando for encontrada uma
correspondência, as declarações ou comandos associados serão executados e o
controle será transferido para a próxima instrução após o END CASE. Se nenhuma
correspondência for encontrada entre as cláusulas WHEN o bloco ELSE será
executado.
Se nenhuma correspondência é encontrada e a cláusula ELSE também estiver

ausente, o comando irá levantar uma exceção CASE_NOT_FOUND. Abaixo
apresentamos a sintaxe para uma instrução CASE simples:
CASE search-expression
WHEN expression THEN
statements
END CASE;
Vamos agora um exemplo prático:
CASE nota
WHEN 7,8,9,10 THEN
status := 'APROVADO';
RETURN status;
16712855225
WHEN 1,2,3,4,5,6 THEN

status := REPROVADO';
RETURN status;
ELSE
status := 'Não apareceu para a prova!';
RETURN grade;
END CASE;
Vamos agora analisar a outra opção para a construção do comando CASE.
A instrução CASE pesquisada executa uma condição com base no resultado da

analise de uma expressão-booleana. É bastante semelhante ao IF-THEN-ELSIF. A
avaliação das expressões continua até que seja encontrada uma correspondência, em
seguida, as declarações ou comandos são executados. O controle é então transferido

PostgreSQL PL/pgSQL
para a próxima instrução após o END CASE. A sintaxe para uma instrução CASE
pesquisada é a seguinte:
CASE
WHEN boolean-expression THEN
Statements
END CASE;
Vamos agora revisitar nosso exemplo anterior pra mostrar como ficaria o
código utilizando essa forma de instrução CASE.
CASE
WHEN nota >=7 AND nota <= 10THEN
status := 'APROVADO';
RETURN status;
WHEN nota>=1 AND nota < 7 THEN
status := REPROVADO';
RETURN status;
ELSE
status := 'Não apareceu para a prova!';
RETURN grade;
END CASE;
Com isso terminamos o estudo das instruções condicionais, vamos agora passar
para os comandos de repetição ou loops.
2.4.2. LOOPS
Loops, como instruções condicionais, são outro método de controle de fluxo de
funções. Os Loops definem a quantidade de iterações para se realizar uma tarefa, e
através do uso de iteração, você pode expandir extremamente a funcionalidade de
uma função PL/pgSQL. Vejamos a sintaxe básica para o loop na figura abaixo:
16712855225
O PL/pgSQL implementa três laços de iteração: O LOOP básico, o loop WHILE

um pouco mais avançado, e o loop FOR. Dos três, é mais provável que você use o
FOR, na maioria dos casos, uma vez que ele pode ser aplicado a diferentes situações,
embora os outros comandos de loops também sejam úteis. Vejam abaixo algumas
formas de utilização do loop FOR:

PostgreSQL PL/pgSQL
Com as declarações LOOP, EXIT, CONTINUE, WHILE, FOR, e FOREACH, você

pode definir que sua função PL/pgSQL deve repetir uma série de comandos.
Observem o exemplo abaixo da sintaxe dos comandos LOOP, IF e EXIT utilizados em
conjunto:
16712855225
2.5. STORED PROCEDURES

Já comentamos no início da nossa aula sobre o fata da sintaxe “stored
procedure” não está presente dentro das palavras reservadas da linguagem
PL/pgSQL. Todos os procedimentos armazenados construídos por meio do comando
CREATE FUNCTION que veremos a seguir.
2.6. FUNCTIONS

PostgreSQL PL/pgSQL
O PL/pgSQL apresenta o comando CREATE FUNCTION para a criação de

procedimentos armazenados. Já observamos ao longo da aula alguns exemplos do
comando, mas não nos preocupamos com os detalhes da sintaxe e os objetivos da
sua utilização. Agora vamos tentar explorar essas e outras peculiaridades do uso do
comando. Todos os comandos de funções em PL/pgSQL devem seguir o padrão
apresentado abaixo:
CREATE OR REPLACE FUNCTION nomedafuncao(paramentroInteiro INTEGER, msg TEXT)

RETURN text AS
$$
DECLARE
strresult TEXT;
BEGIN
IF numtimes > 0 THEN

FOR i IN LOOP
strresult := strresult || msg || E `\r\n`;
END LOOP;
END IF;
RETURN strresult;
END;
$$
LANGUAGE `pgplsql` IMMUTABLE
SECURITY DEFINER
COST 10;
-- Para chamar a função definida acima podemos usar a seguinte sintaxe abaixo e teremos como
-- resultado a mensage
SELECT
No exemplo acima temos na primeira linha a interface da função ou a

assinatura. Ela descreve o nome da função que será utilizado quando formos invocar a
função, bem como os parâmetros que serão necessários com seus respetivos tipos de
dados. Em seguida é definido o tipo de retorno da função. Observe que temos dois
cifrões que aparecem logo em seguida, eles limitam o corpo do procedimento.
16712855225
Dentro do corpo da função temos primeiramente a declaração das variáveis e

seus respectivos tipos. Após a cláusula DECLARE temos o cerne do nosso código.
Nesta parte é possível referenciar as variáveis e os parâmetros pelo seu nome.
Logo na sequência à declaração do corpo da função apresentamos a linguagem

que estamos usando e uma tag que denota a forma como iremos fazer o cache. Neste
caso a palavra chave IMMUTABLE indica que a saída da função é sempre a mesma
quando as entradas forem idênticas. As outras opções seriam STABLE, que limita a
apresentar o mesmo resulta apenas se a função for usada pela mesma consulta com
os mesmos parâmetros, e VOLATILE, esse tipo de função envolve algum
processamento randômico ou o timestamp atual, o que pode levar o resultado a ser
sempre diferente.

PostgreSQL PL/pgSQL
A partir do posgres 8.3 foi introduzida a opção de definir o custo estimado para
uma determinada função, está é determinada pela palavra chave COST que prevê a
quantidade de linhas retornadas pela função. O outro parâmetro encontrado no código
é dado pelas palavras SECUIRTY DEFINER. Essa opção diz que, se a função for
definida no contexto ou num nível de segurança, quando for invocada por outro
usuário ela terá as mesmas permissões de execução que o usuário que definiu a
função. Mesmo que o usuário que executou não tenha tais permissões.
Essa foi nossa rápida apresentação às FUNCTIONS descritas dentro do contexto

de PL/pgSQL. Vamos agora falar dos gatilhos ou TRIGGERS.
2.7. TRIGGERS
O PL/pgSQL pode ser usado para definir os procedimentos de gatilhos. Um
procedimento de gatilho é criado com o comando CREATE FUNCTION, declarando-o
como uma função sem argumentos e tipo de retorno de TRIGGER. Note que a função
deve ser declarada sem argumentos mesmo que você espere receber argumentos
especificados no CREATE TRIGGER - argumentos do gatilho são passados pelo
parâmetro TG_ARGV.
Quando uma função PL/pgSQL é chamada como um gatilho, diversas variáveis

especiais são criadas automaticamente no bloco de nível superior, TG_AGRV é uma
delas. Uma função de gatilho deve retornar NULL ou um valor de registro/linha com
exatamente a mesma estrutura da tabela sobre a qual o gatilho foi disparado. Abaixo
segue mais alguns exemplos de variáveis especiais do PL/pgSQL.
16712855225
Vamos agora apresentar um exemplo de gatilho. Ele garante que qualquer

inserção, atualização ou exclusão de uma linha na tabela emp é gravada na tabela de
emp_audit. A hora atual e nome de usuário são carimbados na linha, juntamente com
o tipo de operação executada nele.
PostgreSQL PL/pgSQL
Com isso terminamos o escopo da nossa aula de PL/SQL, esperamos que vocês
tenham curtido! Não deixem de seguir minha página no facebook (Prof. Thiago
Cavalcanti) e o meu perfil no periscope, neles faço comentários semanais sobre banco
de dados e BI para concursos públicos.
16712855225

PostgreSQL PL/pgSQL
Questões Comentadas
Abaixo apresentamos algumas questões relacionadas ao assunto para a sua

melhor fixação do conteúdo. Em seguida, temos uma bateria de questões do CESPE
sobre PostgreSQL. O gabarito encontra-se ao final.
02. BANCA: VUNESP ANO: 2013 ÓRGÃO: COREN-SP PROVA: ANALISTA -

SISTEMAS
O comando do PL/pgSQL que permite obter o efeito de um comando, como por

exemplo, os indicadores de status do sistema, é
A GET DIAGNOSTICS ...
B EXCEPTION DIAGNOSTICS ...
C MERGE DIAGNOSTICS ...
D NOTICE DIAGNOSTICS ...
E RAISE DIAGNOSTICS ...
Gabarito A. Existem várias formas de determinar o efeito de um comando. O

primeiro método é usar o comando GET DIAGNOSTICS, que tem a forma:
GET DIAGNOSTICS variável = item [, ...];
Veja que este comando é o gabarito da nossa questão. Ele permite a recuperação dos
indicadores de status do sistema. Cada item é uma palavra chave que identifica o
valor de estado a ser atribuído à variável especificada. Os itens de status disponíveis
atualmente são ROW_COUNT, o número de linhas processadas pelo último comando
16712855225
SQL enviado para a máquina SQL, e RESULT_OID, o OID da última linha inserida pelo
comando SQL mais recente. Note que RESULT_OID só é útil depois de um comando
INSERT em uma tabela contendo OIDs. Vejamos um exemplo:
GET DIAGNOSTICS integer_var = ROW_COUNT;
O segundo método para determinar os efeitos de um comando é verificar a variável

especial FOUND, que é do tipo boolean. FOUND é iniciada como falsa dentro de cada
chamada de função PL/pgSQL. Ela é definida por cada um dos seguintes tipos de
declarações:
A instrução SELECT INTO define FOUND como TRUE quando uma linha é atribuída,
falso se nenhuma linha é retornada.

PostgreSQL PL/pgSQL
A instrução PERFORM define FOUND como TRUE quando produz (e despreza) uma ou
mais linhas, falso se não produz nenhuma linha.
O UPDATE, INSERT e DELETE definem FOUND como TRUE quando pelo menos uma
linha é afetada, falso se nenhuma linha é afetada.
A instrução FETCH define FOUND como verdade quando retorna uma linha, falso se
nenhuma linha é retornada.
A instrução MOVE atribui a FOUND valor TRUE quando reposiciona com sucesso o
cursor, FALSE contrário.
A instrução FOR define FOUND como TRUE quando interage uma ou mais vezes, caso
contrário FALSE. Isso se aplica a todas as quatro variantes da instrução FOR.
Outras declarações PL/pgSQL não alteram o estado do FOUND. Note em particular que
o EXECUTE muda a saída do GET DIAGNOSTICS, mas não altera o FOUND. FOUND é
uma variável local dentro de cada função PL/pgSQL; quaisquer alterações afetam
apenas a função atual.
03. BANCA: FCC ANO: 2013 ÓRGÃO: TRT - 12ª REGIÃO (SC) PROVA:
ANALISTA JUDICIÁRIO - TECNOLOGIA DA INFORMAÇÃO
Em PostgreSQL, se uma função de um gatilho (trigger) executar comandos SQL,

existe a possibilidade destes comandos também executarem outros gatilhos. Este
processo é conhecido como
A cascading triggers.
B recursive triggers.
C sub-triggers.
16712855225
D indented triggers.
E multi-trigger.
Gabarito A. Sabemos que uma função de gatilho executa comandos SQL, então estes
comandos podem disparar outros gatilhos. Isto é conhecido como gatilhos em cascata
ou cascading triggers. Não há nenhuma limitação para o número de níveis desta
cascata. É possível que as cascatas provoquem uma invocação recursiva do mesmo
gatilho; por exemplo, um INSERT pode executar um comando que insere uma linha
adicional na mesma tabela, fazendo com que o gatilho INSERT possa ser disparado
mais uma vez. É responsabilidade do desenvolvedor, evitar recursão infinita em tais
cenários.

PostgreSQL PL/pgSQL
Dica: Também é possível escrever uma função de gatilho em C, embora a maioria das
pessoas ache que é mais fácil de usar uma das linguagens procedurais.
04. BANCA: FCC ANO: 2013 ORGÃO: TRT - 12ª Região (SC) PROVA: Analista
Judiciário - Tecnologia da Informação
Considere o trecho do comando em SQL abaixo.
CREATE USER MAPPING FOR
Este comando é utilizado para a criação de um mapeamento do usuário para
A um trecho de pesquisa específico.
B uma tabela remota.
C um banco de dados do tipo cluster.
D uma visualização ( VIEW ).
E um servidor estrangeiro ( foreign server ).
Gabarito E. O comando CREATE USER MAPPING FOR, cuja sintaxe completa pode
ser vista abaixo, é utilizado para definir um novo mapeamento entre um usuário e um
servidor externo ou estrangeiro.
16712855225
05. BANCA: FCC ANO: 2012 ORGÃO: MPE-AP – Prova: Analista Ministerial -
Tecnologia da Informação
No banco de dados PostgreSQL, o comando MOVE é utilizado para reposicionar
A uma tabela em um banco de dados.
B uma linha em uma tabela.
C uma coluna em uma linha.
D o cursor sem trazer dados.
E uma view em uma tabela

PostgreSQL PL/pgSQL
Gabarito D. Vamos aproveitar essa questão para falar um pouco sobre cursores. Em
vez de executar uma consulta inteira de uma só vez, é possível criar um cursor que
encapsula a consulta e, em seguida, ler algumas linhas de cada vez. Uma razão para
fazer isso é para evitar o estouro de memória quando o resultado contém um grande
número de linhas. (No entanto, os usuários PL/pgSQL normalmente não precisam se
preocupar com isso, uma vez que quando utilizamos loops automaticamente um
cursor é criado internamente para evitar problemas de memória.) Um uso mais
interessante é retornar uma referência a um cursor que criado por uma função,
permitindo que o ler as linhas. Isso fornece uma maneira eficiente para retornar
grandes conjuntos de linhas em funções.
Todo o acesso aos cursores em PL/pgSQL passa por variáveis de cursor, que são
sempre do tipo de dados especial refcursor. Uma maneira de criar uma variável de
cursor é apenas para declará-la como uma variável do tipo refcursor. Outra forma é
usar a sintaxe declaração do cursor, o que em geral é:
name [ [ NO ] SCROLL ] CURSOR [ ( arguments ) ] FOR query;
Antes de um cursor ser utilizado para recuperar linhas, ele deve ser aberto. (Esta é a
ação equivalente ao comando SQL DECLARE CURSOR.) PL/pgSQL possui três formas
de instrução OPEN. A primeira possibilidade seria o OPEN FOR query (sintaxe: OPEN
unbound_cursorvar [[NO] SCROLL] FOR query). Neste caso, a variável cursor é aberta
e a consulta especificada é entregue para execução. O cursor não pode estar aberto, e
ele deve ter sido declarado como uma variável de cursor não ligado (ou seja, como
uma variável refcursor simples). A consulta deve ser feita por meio do SELECT, ou
qualquer outro comando que retorne linhas (como EXPLAIN).
A outra opção seria OPEN FOR EXECUTE (sintáxe: OPEN unbound_cursorvar [[NO]
SCROLL] FOR EXECUTE query_string [USING expression [, ...]];). E a última opção
seria OPEN BOUND CURSOR (OPEN bound_cursorvar [([argument_name: =]
argument_value [, ...])];) Esta forma de OPEN é usada para abrir uma variável cursor
cuja consulta foi vinculada a ela quando foi declarada. Uma lista de expressões com
valores de argumentos deve aparecer se e somente se o cursor foi declarado com
estes argumentos. Estes valores serão substituídos na consulta.
16712855225
Uma vez que o cursor tenha sido aberto, ele pode ser manipulado com as instruções
descritas abaixo. Estas manipulações podem não ocorre na mesma função que abriu o
cursor. Você pode retornar um valor refcursor fora da função e deixar a outra função
operar o cursor. São três os principais comandos:
1. FETCH - recupera a próxima linha do cursor no target, que pode ser uma linha, um
registro, ou uma lista de variáveis simples, separadas por vírgulas, da mesma forma
que o comando SELECT INTO. Se não houver nenhuma linha seguinte, o alvo é
definido como NULL(s). Tal como acontece com SELECT INTO, a variável especial
FOUND pode verificar se uma linha foi obtida ou não.
2. MOVE - reposiciona um cursor sem recuperar os dados. O MOVE funciona

exatamente como o comando FETCH, exceto que só reposiciona o cursor e não

PostgreSQL PL/pgSQL
retorna a linha para qual mudou o ponteiro. Aqui também é possível usar a variável
especial FOUND para verificar para ver se uma linha será obtida pelo próximo
comando MOVE.
3. CLOSE - fecha o cursor aberto. Pode ser utilizado para libertar recursos antes do
final da operação, ou para liberar a variável cursor para ser aberta novamente.
Vejam que o exposto acima, apenas confirma nossa resposta na alternativa D.
06. BANCA: FCC ANO: 2012 ORGÃO: MPE-AP - Analista Ministerial PROVA:
Tecnologia da Informação
No banco de dados PostgreSQL, o comando utilizado para efetivar a transação

corrente é chamado
A END.
B ROLLBACK.
C TRANSFER.
D EFFECTIVE.
E SELECT.
Gabarito A. São seis os principais comandos utilizados para trabalhar com transações
dentro do PostgreSQL: START TRANSACTION, BEGIN, COMMIT, ROLLBACK,
SAVEPOINT e SET TRANSACTION. Vejamos a sintaxe e a definição de cada uma deles.
START TRANSACTION - Este comando inicia um novo bloco de transação. Se o nível

de isolamento, modo de leitura/gravação, ou o modo deferrable forem especificado, a
nova transação tem essas características, como se SET TRANSACTION fosse
16712855225
executado. Este é o mesmo que o comando BEGIN.
O BEGIN tem a mesma função do START TRANSACTION. Ou seja, o BEGIN inicia um

bloco de transação, todas as declarações após o comando BEGIN serão executadas
em uma única transação até que um COMMIT ou ROLLBACK explícito. Por padrão
(sem o BEGIN), o PostgreSQL executa as transações em modo "autocommit", isto é,
cada comando é executado em sua própria transação e uma efetivação é

PostgreSQL PL/pgSQL
implicitamente realizada ao final do comando (se a execução for bem sucedida, caso
contrário, um rollback é realizado).
Os comandos são executados mais rapidamente em um bloco de transação, porque a

transação iniciar/commit requer uso significativo de CPU e do disco. A execução de
vários comandos em uma única transação também é útil para garantir a consistência
ao fazer várias alterações relacionadas: outras sessões não serão capazes de ver os
estados intermediários das atualizações relacionadas.
O comando de COMMIT efetiva a transação corrente. Todas as alterações feitas pela

transação se tornam visíveis para os outros e são garantidas para serem duráveis,
mesmo que uma falha acontecer. Sua sintaxe é bem simples.
COMMIT [ WORK | TRANSACTION ]
Uma opção ao COMMIT é o END que também confirma a transação atual. Este
comando é uma extensão do PostgreSQL que é equivalente ao COMMIT.
ROLLBACK reverte a transação atual e faz com que todas as modificações realizadas
pela transação sejam descartadas. Sua sintaxe é semelhante a do commit.
ROLLBACK [ WORK | TRANSACTION ]
O SAVEPOINT estabelece um novo savepoint dentro da transação corrente. Um

savepoint é uma marca especial dentro de uma transação que permite que todos os
comandos que são executados depois as sua criação sejam revertidos, restaurando o
estado de transação para o momento do savepoint.
Observem que, pelo exposto, podemos marcar a alternativa A, visto que COMMIT e
END provocam o mesmo resultado para o PostgreSQL.
07. BANCA: FCC ANO: 2012 ORGÃO: MPE-AP - Técnico Ministerial PROVA:
16712855225
Informática
Em bancos de dados PostgreSQL, o comando DECLARE é utilizado para
A criar uma classe de operadores que define como um determinado tipo de dado pode
ser usado em um índice.
B criar cursores, que podem ser utilizados para retornar, de cada vez, um pequeno
número de linhas em uma consulta.
C criar uma tabela, inicialmente vazia, no banco de dados corrente.
D registrar um novo tipo de dado para uso no banco de dados corrente.
E registrar uma nova linguagem procedural a ser utilizada em consultas ao banco de

dados.

PostgreSQL PL/pgSQL
Gabarito B. Vejam que podemos pensar em duas opções para o uso do DECLARE.
Quando queremos criar um cursor ou quando estamos utilizando PL/pgSQL e
utilizamos o DECLARE no bloco para declaramos as variáveis a serem utilizadas pelo
comando. A questão optou por questionar o uso do DECLARE na criação de cursores.
Observem que as demais alternativas não fazem sentido. Como tarefa, tente acha o
comando que executa cada uma das operações descritas nas demais alternativas.
08. BANCA: FCC ANO: 2012 ORGÃO: MPE-AP - Técnico Ministerial PROVA:
Informática
Quando o nível de isolamento de uma transação em SQL no banco de

dados PostgreSQL é definido como serializável (Serializable), o comando
SELECT enxerga apenas os dados efetivados
A durante a transação, desde que as transações concorrentes tenham feito COMMIT.

B por transações simultâneas.
C após o início da transação, desde que as transações simultâneas tenham efetivado
as alterações no banco de dados.
D antes de a transação começar.
E durante a transação, desde que as transações concorrentes não tenham
feito COMMIT.
Gabarito D. Sabemos que o nível de isolamento serializável as operações são

executas isoladamente. Nestes casos só podemos visualizar dados efetivados antes de
a transação começar.
09. BANCA: FCC ANO: 2012 ORGÃO: MPE-PE - Técnico Ministerial PROVA:
16712855225
Informática
Em PostgreSQL, um conjunto de funções e expressões estão disponíveis para a

geração de arquivos XML. A função, similar a função xmlconcat, que concatena as
colunas xml entre linhas de uma tabela é denominada de
A xmllist.
B xmlrowcat.
C xmlgrep.
D xmlagg.
E xmlconcr.

PostgreSQL PL/pgSQL
Gabarito D. Vejamos o que as ações feitas por cada uma das funções xml da
questão. Antes, porém, precisamos eliminar da nossa analise as alternativas que não
são funções XML. Eliminamos as letras A, B, C e E.
A função xmlagg é, ao contrário das outras funções descritas na documentação, uma

função de agregação. Ela concatena os valores de entrada para a chamada de função
agregada, tal como XMLCONCAT faz, exceto que a concatenação ocorre em todas as
linhas, em vez de em uma única linha.
Para a lista completa das funções XML sugiro olhar a documentação oficial aqui.
16712855225

PostgreSQL PL/pgSQL
Questões PostgreSQL - CESPE
1) Ano: 2015 Banca: CESPE Órgão: STJ Prova: Analista Judiciário -

Infraestrutura
[1] No PostgresSQL, com a execução do comando initdb para criação de um
database cluster, será solicitada inicialmente ao operador a definição de um
nome de usuário com até oito caracteres.
2) Banca: CESPE Ano: 2014 Órgão: TJ-CE Prova: Analista Judiciário -

Ciências da Computação
A respeito do PostgreSQL 9.3 em Linux, assinale a opção correta.
A No Linux, entre os métodos de autenticação permitidos, é possível utilizar a
autenticação por PAM (Pluggable Authentication Modules) sem a possibilidade
de utilizar LDAP para esse método. Essa autenticação deve, por default, ser
configurada para acessar o diretório /etc/shadow, uma vez que o postmaster
é, a partir da versão 9.1, executado como administrador do sistema.
B Na instalação do PostgreSQL no Linux, é necessário informar ao sistema
como encontrar as bibliotecas compartilhadas por meio da diretiva
LD_LIBRARY_PATH = <caminho>. Essa configuração deve ser mantida
também depois da instalação no arquivo postgresql.conf, para que, quando o
PostgreSQL estiver em execução, seja possível realizar o fork do processo
postmaster. 16712855225
C O PostgreSQL permite a autenticação de pares (peer) no Linux por meio do

uso de mapas para descrever as conexões e relações de confiança entre
servidores. Tais configurações devem ser realizadas no arquivo
pg_service.conf, com uma linha para cada conexão individual.
D No Linux 2.4 e em versões posteriores desse software, o comportamento
padrão de memória virtual não é o ideal para o PostgreSQL, pois o sistema
operacional poderá interromper o postmaster caso o sistema fique sem
memória virtual. Uma maneira de evitar esse problema é executar o
PostgreSQL em uma máquina na qual os outros processos não vão deixá-la
sem memória ou ainda aumentar o espaço de swap do sistema operacional.
E O PostgreSQL oferece criptografia em vários níveis de campos, tabelas,
bancos de dados e de partições inteiras. Se for instalado no Linux, o

PostgreSQL PL/pgSQL
PostgreSQL somente realizará a criptografia de campos e tabelas, devido à

proteção nos sistemas de arquivos do Linux.
3) Banca: CESPE Ano: 2015 Órgão: CGE-PI Prova: Auditor

Governamental - Tecnologia da Informação
Acerca de bancos de dados, julgue os itens a seguir.
[1] No PostgreSQL 9.3, os arquivos de WAL (write-ahead logging), que
armazenam as transações do SGBD na forma de segmentos de log, são
gravados por padrão no diretório pg_wal abaixo do diretório data.
4) Banca: CESPE Ano: 2010 Órgão: INMETRO Prova: Pesquisador -

Gestão da Informação
Considerando um estudo comparativo entre os sistemas gerenciadores de
banco de dados Oracle, MySQL, PostgreSQL e SQL Server, assinale a opção
correta.
A Enquanto MySQL é um SGBD unificado que usa um único engine de storage,
uma única instância de PostgreSQL pode servir a várias bases de dados
armazenadas com engines distintos.
B MyISAM, InnoDB e NDB são engines suportados por MySQL, sendo que,
destes, apenas MyISAM e InnoDB garantem as propriedades ACID em
transações.
C Os SGBDs Oracle, MySQL, PostgreSQL e SQL Server possuem soluções
nativas para balanceamento de carga, clusterização e replicação.
16712855225
D Se uma base de dados Oracle possui o parâmetro de point in time recovery

de 7 dias, então é possível ao administrador desse banco de dados recuperar o
estado do banco para qualquer ponto do tempo nas últimas 24 horas × 7 dias
passados.
E As linguagens de consultas comumente usadas no SQL Server são Transact-
SQL e PL/SQL.
5) Banca: CESPE Ano: 2014 Órgão: ANATEL Prova: Analista

Administrativo - Suporte e Infraestrutura de TI
PostgreSQL PL/pgSQL
A respeito de banco de dados, julgue os itens que se seguem.

[1] O PostgreSQL 9.3, ao gerenciar o controle de concorrência, permite o
acesso simultâneo aos dados. Internamente, a consistência dos dados é
mantida por meio do MVCC (multiversion concurrency control), que impede
que as transações visualizem dados inconsistentes.

É válida para o PostgreSQL 9.3, mas não para o SQL Server 2012, a criação da
SEQUENCE seqa por meio do seguinte comando:
CREATE SEQUENCE seqa START WITH 1;

[1] A conexão com o PostgreSQL 9.3 é realizada, por padrão, na porta TCP
5432. Uma das configurações de segurança permitida é o acesso por meio de
SSL que é true, por padrão, e é aceito, neste caso, com o uso dos protocolos
TCP, IP ou NTP.
16712855225
8) Banca: CESPE Ano: 2012 Órgão: BANCO DA AMAZÔNIA Prova:

Técnico Científico - Redes e Telecomunicações
A respeito da instalação do sistema de gerenciamento de banco de dados
(SGBD) Postegree SQL 9.1 em sistemas Linux, que necessita ser feita
manualmente em alguns casos, julgue os itens a seguir.
[1] Para uma instalação básica, após a verificação de alguns requisitos básicos
e a descompactação do pacote de software, o comando ./configure deve ser
executado no diretório em que o software tiver sido descompactado.

PostgreSQL PL/pgSQL
9) Banca: CESPE Ano: 2012 Órgão: BANCO DA AMAZÔNIA Prova:

Técnico Científico - Redes e Telecomunicações
A respeito da instalação do sistema de gerenciamento de banco de dados

(SGBD) Postegree SQL 9.1 em sistemas Linux, que necessita ser feita
manualmente em alguns casos, julgue os itens a seguir.
[1] É impossível fazer a instalação do Postgree SQL com suporte ao protocolo

LDAP.
10) Banca: CESPE Ano: 2013 Órgão: TCE-RO Prova: Analista Judiciário
- Informática
A respeito da utilização do banco de dados relacional em plataforma
PostgreSQL, julgue o próximo item.
[1] Considere que as linhas apresentadas a seguir estejam presentes no
arquivo de nome pg_hba.conf de instalação do PostgreSQL. Nesse caso, será
permitido acesso a todos os computadores, exceto aquele que esteja com o
endereço IP
16712855225
11) Banca: CESPE Ano: 2013 Órgão: MC Prova: Analista de Nível

Superior - Tecnologia da Informação
Acerca do uso da ferramenta pgAdmin III, versão 1.16.1, do banco de dados
Postgre, julgue os próximos itens.
[1] A ferramenta pgAdmin Data Export permite exportar os dados para um
arquivo com a extensão CSV, mantendo o nome das colunas na primeira linha
do arquivo, caso a opção correspondente seja selecionada.

PostgreSQL PL/pgSQL

Postgre, julgue os próximos itens.
[1] O pgAdmin III permite a criação de jobs para executar tarefas
administrativas, contudo não permite incluir comentários nos jobs.

PostgreSQL, julgue os próximos itens.
[1] A ferramenta de consulta Query Tool possui o recurso de autocompletar,
que facilita a escritura dos comandos em SQL pelo usuário.

Postgre, julgue os próximos itens. 16712855225
[1] O utilitário RECREATE permite analisar e remover as linhas das tabelas que
não estão mais em uso, o que aperfeiçoa o desempenho do banco de dados.
15) Ano: 2013 Banca: CESPE Órgão: MPOG Prova: Analista - Tecnologia
da Informação
No que se refere aos sistemas gerenciadores de banco de dados livres, julgue
os itens que se seguem.
[1] No PostgreSQL, é possível atualizar um campo do banco de dados usando-
se o comando a seguir.
PostgreSQL PL/pgSQL
UPDATE a,b SET a.id=b.id WHERE a.f2 = b.f2
16) Banca: CESPE Ano: 2013 Órgão: MPOG Prova: Analista - Tecnologia
da Informação
No que se refere aos sistemas gerenciadores de banco de dados livres, julgue

os itens que se seguem.
[1] PostgreSQL é um software livre licenciado sob a PostgreSQL Licence,

licença similar às licenças BSD e MIT.
17) Banca: CESPE Ano: 2013 Órgão: FUB Prova: Analista - Tecnologia
da Informação
A respeito de banco de dados, julgue os próximos itens.
[1] O processo servidor, denominado postgres, gerencia os arquivos do banco
de dados, aceita conexões para o banco de dados provenientes das aplicações
clientes e executa ações de banco de dados no comportamento do cliente.
18) Banca: CESPE Ano: 2013 Órgão: FUB Prova: Analista - Tecnologia
da Informação
16712855225
A respeito de banco de dados, julgue os próximos itens.

[1] No PostgreSQL 9.3, as funções table_to_xml, query_to_xml e
cursor_to_xml mapeiam os conteúdos de tabelas relacionais para esquemas
XML. Por exemplo, o comando SELECT table_to_xml('books', 'TRUE', 'TRUE', '
') mapeia uma tabela denominada books em um esquema XML.

PostgreSQL PL/pgSQL
19) Banca: CESPE Ano: 2013 Órgão: ANTT Prova: Analista

Administrativo - Desenvolvimento de Sistemas
Julgue os itens subsequentes, relativos a banco de dados.
[1] O phpPgAdmin é uma ferramenta web de administração para o
PostgresSQL que permite gerenciar, em múltiplos servidores, usuários e
grupos, bases de dados, esquemas, tabelas, views e objetos.
20) Banca: CESPE Ano: 2013 Órgão: SERPRO Prova: Analista -

Desenvolvimento de Sistemas
Em relação a banco de dados, julgue os seguintes itens.
[1] No PostgreSQL, diversos gatilhos podem ser associados a uma mesma
condição. Entretanto, se o primeiro gatilho retornar NULL, os demais não serão
executados.
21) Banca: CESPE Ano: 2014 Órgão: TJ-SE Prova: Analista Judiciário -
Banco de Dados
Acerca dos sistemas gerenciadores de banco de dados InterSystems Cache,
PostgreSQL, MySQL e Oracle, julgue os itens subsequentes.
[1] Caso a instrução abaixo seja executada no PostgreSQL 9.3, ela retornará o
espaço em disco utilizado pela tabela processo, desconsiderando-se o espaço
utilizado pelos seus índices.
SELECT pg_table_size('processo'); 16712855225
22) Banca: CESPE Ano: 2010 Órgão: MPU Prova: Analista do MPU -
Analista de Informática - Banco de Dados
Acerca de SGBD Oracle, Postgres e MySQL, julgue os próximos itens.
[1] O PostgresSQL é um sistema de gerenciamento de banco de dados objeto-
relacional (SGBDOR) de código aberto, tendo como linguagem procedural única
de armazenagem o PL/SQL.

PostgreSQL PL/pgSQL
23) Banca: CESPE Ano: 2013 Órgão: TRT - 17ª REGIÃO (ES) Prova:
Analista Judiciário - Tecnologia da Informação
Julgue os itens subsequentes com relação aos comandos SQL.
[1] No PostgreSql 9.3 é possível configurar permissão para usuários até o nível
de tabelas, mas não controles para acesso de colunas. Logo, o comando SQL
abaixo está correto para Oracle 11g, mas não para PostgreSql 9.3.
GRANT SELECT (col1), UPDATE (col1) ON TabelaTeste TO Usuario;
Julgue os itens subsequentes com relação aos comandos SQL.
No PostgreSql 9.3, os dois comandos abaixo retornam true como resultado.
SELECT 'abc' SIMILAR TO '%(b|d)%'
SELECT 'abc' SIMILAR TO '(b|c)%'
16712855225
No que se refere aos sistemas de gerenciadores de banco de dados (SGBD),

julgue os itens seguintes.
O PostgreSql 9.3 permite limitar o tamanho físico máximo em bytes em
tabelas de usuário por meio da cláusula tablespaces no comando CREATE
TABLE, conforme a sintaxe mostrada abaixo.
CREATE TABLE TabelaTeste ( Codigo integer PRIMARY KEY, Nome varchar(40)
NOT NULL ) WITH (TABLESPACES = 1GB);

PostgreSQL PL/pgSQL
Gabarito
1. E
2. D
3. E
4. D
5. C
6. E
7. E
8. C
9. E
10. C
11. C
12. E
13. C
14. E
15. E
16. C
17. C
18. C
19. C
20. C
21. C
22. E
23. E
24. E
25. E
16712855225

PL/pgSQL
‘
Prof. Thiago Rodrigues Cavalcanti Aula xx
Considerações finais
Chegamos, pois, ao final nossa aula que tratou de PL/pgSQL!
Espero que tenha gostado! Desejo a todos bons estudos! E até breve!
Thiago Cavalcanti
Referências
Fiz uma lista com alguns links de referências caso você queria se
aprofundar um pouco.
i. Para saber um pouco mais sobre administração de bancos de dados
PostgreSQL - http://www.postgresql.org/docs/9.4/static/admin.html
ii. Informações sobre o catálogo de dados do PostgreSQL -
http://www.postgresql.org/docs/9.1/static/catalogs.html
iii. Novas funcionalidades do PostreSQL 9.4 -
https://wiki.postgresql.org/wiki/What's_new_in_PostgreSQL_9.4
iv. Informações do PostgreSQL na Wikipedia -
https://en.wikipedia.org/wiki/PostgreSQL
v. PL/pgSQL - http://www.postgresql.org/docs/9.5/static/plpgsql.html
16712855225
Prof. Thiago Rodrigues Cavalcanti

www.estrategiaconcursos.com.br 35 de 35

Pacote para Concursos de Ti Cursos Regulares Sgbds para Concursos Curso Regular Aula 03

Enviado por

Dados do documento

Descrição:

Título original

Direitos autorais

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Descrição:

Direitos autorais:

Pacote para Concursos de Ti Cursos Regulares Sgbds para Concursos Curso Regular Aula 03

Título original:

Enviado por

Descrição:

Direitos autorais:

Aula 03

SGBDs para Concursos - Curso Regular

AULA 03: PL/pgSQL

Essa aula tem por objetivo apresentar a versatilidade das linguagens

Vamos imaginar duas situações distintas. Na primeira você executa comandos

utilizadas para escrevermos funções. No caso de PL/pgSQL, as funções são uma

1.1. Por que você deve usar PL/pgSQL?

As instruções SQL são executadas individualmente, sendo assim suas consultas

em PL/pgSQL podem chamar outras funções ou conter sub-blocos dentro do bloco de

1.2. Instalando PL/pgSQL

Prof. Victor Dalton www.estrategiaconcursos.com.br 2 de 35

comandos, declarações, funções e assim por diante. Na verdade, a documentação

2. Entendendo a estrutura do PL/pgSQL

Cada declaração (declaration) e cada instrução (statement) dentro de um bloco

2.1. Usando Variáveis

Prof. Victor Dalton www.estrategiaconcursos.com.br 4 de 35

Observem a presença de um sub-bloco e a utilização da variável quantity. Seu

name [ CONSTANT ] type [ COLLATE collation_name ] [ NOT NULL ] [ {

A cláusula DEFAULT, caso exista, especifica o valor inicial atribuído à variável

Prof. Victor Dalton www.estrategiaconcursos.com.br 5 de 35

01. BANCA: VUNESP ANO: 2013 ÓRGÃO: COREN-SP PROVA: ANALISTA -

Na linguagem PL/pgSQL, o comando para declarar uma constante, de nome ‘mouse’,

A pg_CONST mouse :=3;

B pg_CONST mouse, INTEGER 3;

C pg mouse CONST, DEFAULT := 3;

E mouse CONSTANT INTEGER := 3;

Resumindo, as variáveis são usadas no código PL/pgSQL para armazenar dados

2.2. Trabalhando com erros e exceções -

Prof. Victor Dalton www.estrategiaconcursos.com.br 6 de 35

A instrução RAISE também é descreve o nível de erro que trata do grau de

A opção level especifica a gravidade do erro. Os níveis permitidos são DEBUG,

Você pode anexar informações adicionais ao relatório de erro por escrito,

DETAIL- Fornece uma mensagem de detalhe erro.

ERRCODE - Especifica o código de erro (SQLSTATE) reportado.

Vejam mais um exemplo abaixo onde apresentamos uma forma de utilização do

Prof. Victor Dalton www.estrategiaconcursos.com.br 7 de 35

2.3. Chamadas e retornos de função

SELECT function_identifier (arguments);

O uso de atribuições e instruções de SELECT para executar funções é o padrão

Existem, ainda, dois comandos disponíveis que permitem ao usuário retornar

Aqui está um exemplo de uma função usando RETURN NEXT:

Prof. Victor Dalton www.estrategiaconcursos.com.br 8 de 35

Vejamos agora algumas informações a respeito das estruturas de controle e

2.4. Estruturas de controle

As estruturas de controle são, provavelmente, a parte mais útil (e importante)

As declarações IF e CASE permitem que você execute comandos

 IF ... THEN ... ELSE

 IF ... THEN ... ELSIF ... THEN ... ELSE

Prof. Victor Dalton www.estrategiaconcursos.com.br 9 de 35

 CASE WHEN ... THEN ... ELSE ... END CASE

Vamos agora detalhar um pouco mais cada um desses comandos verificando

2.4.1. Comandos condicionais

CREATE FUNCTION identifier (arguments) RETURNS type AS '

Vamos começar a observar códigos um pouco mais complexos. No exemplo a

CREATE FUNCTION stock_amount (integer, integer) RETURNS integer AS '

b_id ALIAS FOR $1;

Prof. Victor Dalton www.estrategiaconcursos.com.br 10 de 35

SELECT INTO b_isbn isbn FROM editions WHERE

IF b_isbn IS NULL THEN

SELECT INTO stock_amount stock FROM stock WHERE isbn = b_isbn;

A instrução IF/THEN/ELSE permite que você especifique um bloco de instruções

CREATE FUNCTION identifier (arguments) RETURNS type AS '